Refresh HiveGrid Cloud reference snapshot

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

No files matched your search

@@ -0,0 +1,280 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
function portalRequest(input: string | URL, init: RequestInit = {}): Request {
const url = input instanceof URL ? input : new URL(input);
const headers = new Headers(init.headers);
headers.set("x-hivegrid-portal-tenant", "acme");
headers.set("x-hivegrid-portal-origin", url.origin);
return new Request(url, { ...init, headers });
}
const mocks = vi.hoisted(() => ({
requirePortalTenantFromRequest: vi.fn(async () => ({
tenantId: "tenant_1",
portalId: "portal_1",
tenantSlug: "acme",
tenantName: "Acme GmbH",
portalTitle: "Acme Portal",
tenantActive: true,
tenantFrozen: false,
imprintUrl: "https://acme.example.test/imprint",
privacyUrl: "https://acme.example.test/privacy",
termsUrl: null,
})),
consumePortalCapability: vi.fn(),
requestPortalSignInLink: vi.fn(),
signInPortalWithPassword: vi.fn(),
validatePortalCsrfToken: vi.fn(),
serializePortalSessionCookie: vi.fn(),
}));
vi.mock("@hivegrid/config", () => ({
loadRequiredWebConfig: () => ({
supportEmail: "support@example.test",
captcha: {
provider: "mcaptcha",
instanceUrl: "https://captcha.example.test",
loginSiteKey: "site-key",
},
}),
}));
vi.mock("~/components/captcha/Captcha", () => ({ default: () => null }));
vi.mock("~/components/screens/customer-portal/CustomerPortalInterimPages", () => ({
CustomerPortalAuthPage: () => null,
}));
vi.mock("~/services/customer-portal/portal-auth-flow.server", () => ({
consumePortalCapability: (...args: unknown[]) => mocks.consumePortalCapability(...args),
requestPortalPasswordReset: vi.fn(),
requestPortalSignInLink: (...args: unknown[]) => mocks.requestPortalSignInLink(...args),
signInPortalWithPassword: (...args: unknown[]) => mocks.signInPortalWithPassword(...args),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({
validatePortalCsrfToken: (...args: unknown[]) => mocks.validatePortalCsrfToken(...args),
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
portalNotFound: () => new Response(null, { status: 404 }),
requirePortalTenantFromRequest: mocks.requirePortalTenantFromRequest,
}));
vi.mock("~/services/customer-portal/portal-session-cookie.server", () => ({
serializePortalSessionCookie: (...args: unknown[]) => mocks.serializePortalSessionCookie(...args),
}));
import { resolvePortalCapabilityContinuePath } from "~/services/customer-portal/portal-capability-continue.server";
import { action, loader } from "./auth";
beforeEach(() => {
vi.clearAllMocks();
});
describe("customer portal auth loader", () => {
it("never serializes a raw capability token into hydration data", async () => {
const rawToken = "t".repeat(43);
const response = await loader({
request: portalRequest(`https://portal.example.test/__portal/acme/reset-password/${rawToken}`),
params: { tenant: "acme", "*": `reset-password/${rawToken}` },
context: {},
} as never);
const payload = await response.json();
expect(JSON.stringify(payload)).not.toContain(rawToken);
expect(payload.vm.status).toBe("ready");
expect(payload.vm.data).not.toHaveProperty("formAction");
expect(payload.vm.data.legalLinks).toEqual({
imprintUrl: "https://acme.example.test/imprint",
privacyUrl: "https://acme.example.test/privacy",
termsUrl: null,
});
expect(response.headers.get("Referrer-Policy")).toBe("no-referrer");
});
it("leaves ordinary login pages on the server's safe default policy", async () => {
const response = await loader({
request: portalRequest("https://portal.example.test/__portal/acme/login"),
params: { tenant: "acme", "*": "login" },
context: {},
} as never);
expect(response.headers.get("Referrer-Policy")).toBeNull();
});
it("parses a slugless custom-host data request as the same login route", async () => {
const request = portalRequest("https://kunden.example.org/login.data");
request.headers.set("x-hivegrid-portal-custom-host", "kunden.example.org");
const response = await loader({ request, params: {}, context: {} } as never);
const payload = await response.json();
expect(payload.vm.status).toBe("ready");
expect(payload.vm.data.mode).toBe("login");
expect(payload.vm.data.tenantSlug).toBe("acme");
expect(payload.vm.data.loginHref).toBe("/login");
expect(payload.vm.data.passwordHref).toBe("/forgot-password");
});
});
describe("customer portal capability continuation", () => {
it("accepts only an exact same-tenant project-detail path", () => {
const valid = portalRequest("https://portal.example.test/__portal/acme/login/magic/token?continue=%2Facme%2Fprojects%2Fproject_123");
expect(resolvePortalCapabilityContinuePath(valid, "acme")).toBe("/acme/projects/project_123");
});
it.each([
"https://evil.example/projects/project_123",
"//evil.example/projects/project_123",
"/other/projects/project_123",
"/acme/projects/project_123/extra",
"/acme/projects/../settings",
"%2Facme%2Fprojects%2Fproject_123",
])("falls back to the dashboard for rejected continue value %s", (continueValue) => {
const url = new URL("https://portal.example.test/__portal/acme/login/magic/token");
url.searchParams.set("continue", continueValue);
expect(resolvePortalCapabilityContinuePath(portalRequest(url), "acme")).toBe("/acme");
});
it("rejects ambiguous repeated continuation parameters", () => {
const request = portalRequest(
"https://portal.example.test/__portal/acme/login/magic/token?continue=%2Facme%2Fprojects%2Fone&continue=%2Facme%2Fprojects%2Ftwo"
);
expect(resolvePortalCapabilityContinuePath(request, "acme")).toBe("/acme");
});
it("redirects a successfully consumed magic capability to its validated project", async () => {
const rawToken = "t".repeat(43);
mocks.consumePortalCapability.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const request = portalRequest(`https://portal.example.test/__portal/acme/login/magic/${rawToken}?continue=%2Facme%2Fprojects%2Fproject_123`, {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha" }),
});
let response: Response | undefined;
try {
await action({
request,
params: { tenant: "acme", "*": `login/magic/${rawToken}` },
context: {},
} as never);
} catch (error) {
response = error as Response;
}
expect(response?.status).toBe(302);
expect(response?.headers.get("Location")).toBe("/acme/projects/project_123");
expect(response?.headers.get("Set-Cookie")).toBe("__Host-hivegrid_portal_session=signed");
});
it("carries a validated project continuation through regular magic-link request and magic-sent", async () => {
mocks.requestPortalSignInLink.mockResolvedValueOnce({ ok: true, kind: "sent" });
const request = portalRequest("https://portal.example.test/__portal/acme/login?continue=%2Facme%2Fprojects%2Fproject_123", {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha", intent: "magic_link", email: "customer@example.test" }),
});
let response: Response | undefined;
try {
await action({ request, params: { tenant: "acme", "*": "login" }, context: {} } as never);
} catch (error) {
response = error as Response;
}
expect(mocks.requestPortalSignInLink).toHaveBeenCalledWith(
expect.objectContaining({ email: "customer@example.test", continuePath: "/acme/projects/project_123" })
);
expect(response?.status).toBe(302);
expect(response?.headers.get("Location")).toBe("/acme/login/magic-sent?continue=%2Facme%2Fprojects%2Fproject_123");
});
it("redirects regular password login to the same validated project continuation", async () => {
mocks.signInPortalWithPassword.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const request = portalRequest("https://portal.example.test/__portal/acme/login?continue=%2Facme%2Fprojects%2Fproject_123", {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha", intent: "password", email: "customer@example.test", password: "secret" }),
});
let response: Response | undefined;
try {
await action({ request, params: { tenant: "acme", "*": "login" }, context: {} } as never);
} catch (error) {
response = error as Response;
}
expect(response?.status).toBe(302);
expect(response?.headers.get("Location")).toBe("/acme/projects/project_123");
});
it.each(["/other/projects/project_123", "//evil.example/projects/project_123", "https://evil.example/projects/project_123"])(
"drops manipulated or foreign-tenant continuation from regular auth: %s",
async (continueValue) => {
mocks.signInPortalWithPassword.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const url = new URL("https://portal.example.test/__portal/acme/login");
url.searchParams.set("continue", continueValue);
const request = portalRequest(url, {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha", intent: "password", email: "customer@example.test", password: "secret" }),
});
let response: Response | undefined;
try {
await action({ request, params: { tenant: "acme", "*": "login" }, context: {} } as never);
} catch (error) {
response = error as Response;
}
expect(response?.headers.get("Location")).toBe("/acme");
}
);
it("passes an omitted password through first-time setup without inventing credentials", async () => {
const rawToken = "t".repeat(43);
mocks.consumePortalCapability.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const request = portalRequest(`https://portal.example.test/__portal/acme/setup/${rawToken}`, {
method: "POST",
body: new URLSearchParams({
csrf: "csrf",
captchaToken: "captcha",
privacyNoticeAcknowledged: "true",
privacyNoticeUrl: "https://acme.example.test/privacy",
}),
});
try {
await action({ request, params: { tenant: "acme", "*": `setup/${rawToken}` }, context: {} } as never);
} catch (error) {
expect((error as Response).status).toBe(302);
}
expect(mocks.consumePortalCapability).toHaveBeenCalledWith(
expect.objectContaining({
rawToken,
purpose: "setup",
password: undefined,
passwordConfirmation: undefined,
privacyNoticeAcknowledged: true,
privacyNoticeUrl: "https://acme.example.test/privacy",
})
);
});
});
@@ -0,0 +1,230 @@
import { useEffect, useRef } from "react";
import { loadRequiredWebConfig } from "@hivegrid/config";
import { buildPortalAuthVM, type PortalAuthMode, type PortalLegalLinks } from "@hivegrid/view-models";
import { redirect, useFetcher, useLoaderData, useLocation, useNavigate, useRevalidator, type ActionFunctionArgs, type LoaderFunctionArgs } from "react-router";
import Captcha from "~/components/captcha/Captcha";
import { CustomerPortalAuthPage, type PortalAuthSubmission } from "~/components/screens/customer-portal/CustomerPortalInterimPages";
import {
consumePortalCapability,
requestPortalPasswordReset,
requestPortalSignInLink,
signInPortalWithPassword,
type PortalAuthResult,
} from "~/services/customer-portal/portal-auth-flow.server";
import { readPortalProjectContinuePath } from "~/services/customer-portal/portal-capability-continue.server";
import { validatePortalCsrfToken } from "~/services/customer-portal/portal-csrf.server";
import { portalNotFound, requirePortalTenantFromRequest } from "~/services/customer-portal/portal-data.server";
import { serializePortalSessionCookie } from "~/services/customer-portal/portal-session-cookie.server";
import { portalPublicPath, requireTrustedPortalOrigin } from "~/services/customer-portal/portal-origin.server";
type AuthDescriptor = {
readonly mode: PortalAuthMode;
readonly token: string | null;
readonly purpose: "magic_link" | "setup" | "verify_email" | "reset_password" | null;
};
export async function loader({ request, params }: LoaderFunctionArgs) {
const tenant = await requirePortalTenantFromRequest(request, params.tenant);
const origin = requireTrustedPortalOrigin(request, tenant.tenantSlug);
const descriptor = parseAuthDescriptor(resolveAuthPath(request, params["*"], origin.customHost));
const config = loadRequiredWebConfig();
return Response.json(
{
vm: buildPortalAuthVM({
tenantSlug: tenant.tenantSlug,
tenantName: tenant.tenantName,
portalName: tenant.portalTitle,
legalLinks: requirePortalLegalLinks(tenant),
mode: descriptor.mode,
allowPassword: descriptor.mode === "login",
captchaRequired: descriptor.mode !== "magic_sent" && descriptor.mode !== "invalid_token",
loginHref: portalPublicPath(origin, "login"),
passwordHref: portalPublicPath(origin, "forgot-password"),
supportEmail: config.supportEmail,
}),
captcha: {
provider: config.captcha.provider,
instanceUrl: config.captcha.instanceUrl,
sitekey: config.captcha.loginSiteKey,
},
brandingLogoHref: portalPublicPath(origin, "branding/logo"),
},
{ headers: getAuthSecurityHeaders(descriptor) }
);
}
export async function action({ request, params }: ActionFunctionArgs) {
const tenant = await requirePortalTenantFromRequest(request, params.tenant);
const origin = requireTrustedPortalOrigin(request, tenant.tenantSlug);
const descriptor = parseAuthDescriptor(resolveAuthPath(request, params["*"], origin.customHost));
if (descriptor.mode === "magic_sent" || descriptor.mode === "invalid_token") throw portalNotFound();
const continuePath = readPortalProjectContinuePath(request, origin);
const form = await request.clone().formData();
await validatePortalCsrfToken(request, form);
const captchaToken = stringValue(form.get("captchaToken")) ?? stringValue(form.get("cap-token")) ?? stringValue(form.get("mcaptcha__token"));
let result: PortalAuthResult;
if (descriptor.mode === "login") {
const intent = stringValue(form.get("intent"));
const email = stringValue(form.get("email")) ?? "";
result =
intent === "password"
? await signInPortalWithPassword({
request,
tenant,
email,
password: stringValue(form.get("password")) ?? "",
captchaToken,
})
: await requestPortalSignInLink({ request, tenant, email, captchaToken, continuePath });
} else if (descriptor.mode === "forgot_password") {
result = await requestPortalPasswordReset({
request,
tenant,
email: stringValue(form.get("email")) ?? "",
captchaToken,
});
} else {
if (!descriptor.token || !descriptor.purpose) throw portalNotFound();
const capabilityInput = {
request,
tenant,
rawToken: descriptor.token,
purpose: descriptor.purpose,
captchaToken,
password: stringValue(form.get("password")) ?? undefined,
passwordConfirmation: stringValue(form.get("passwordConfirmation")) ?? undefined,
privacyNoticeAcknowledged: optionalBooleanValue(form.get("privacyNoticeAcknowledged")),
privacyNoticeUrl: stringValue(form.get("privacyNoticeUrl")) ?? undefined,
};
result = await consumePortalCapability(capabilityInput);
}
if (!result.ok) {
return Response.json({ errorKey: result.errorKey }, { status: result.status, headers: { "Cache-Control": "no-store" } });
}
if (result.kind === "sent") {
throw redirect(withPortalContinue(portalPublicPath(origin, "login/magic-sent"), continuePath), { headers: { "Cache-Control": "no-store" } });
}
const redirectPath = continuePath ?? portalPublicPath(origin);
throw redirect(redirectPath, {
headers: {
"Cache-Control": "no-store",
"Set-Cookie": await serializePortalSessionCookie(result.rawSessionToken, result.expiresAt),
},
});
}
function withPortalContinue(path: string, continuePath: string | null): string {
return continuePath ? `${path}?continue=${encodeURIComponent(continuePath)}` : path;
}
export default function CustomerPortalAuthRoute() {
const { vm, captcha, brandingLogoHref } = useLoaderData<typeof loader>();
const fetcher = useFetcher<typeof action>();
const location = useLocation();
const navigate = useNavigate();
const { revalidate } = useRevalidator();
const revalidatedPrivacyFailure = useRef<unknown>(null);
const errorKey = fetcher.data && "errorKey" in fetcher.data ? fetcher.data.errorKey : null;
useEffect(() => {
if (errorKey !== "customerPortal.auth.errors.privacyNoticeChanged" || fetcher.data === revalidatedPrivacyFailure.current) {
return;
}
revalidatedPrivacyFailure.current = fetcher.data;
void revalidate();
}, [errorKey, fetcher.data, revalidate]);
const submit = (submission: PortalAuthSubmission) => {
const form = new FormData();
form.set("intent", submission.intent);
if (submission.email) form.set("email", submission.email);
if (submission.password) form.set("password", submission.password);
if (submission.passwordConfirmation) form.set("passwordConfirmation", submission.passwordConfirmation);
if (submission.captchaToken) form.set("captchaToken", submission.captchaToken);
if (submission.privacyNoticeAcknowledged !== undefined) {
form.set("privacyNoticeAcknowledged", String(submission.privacyNoticeAcknowledged));
}
if (submission.privacyNoticeUrl !== undefined) form.set("privacyNoticeUrl", submission.privacyNoticeUrl);
const csrf = document.querySelector<HTMLMetaElement>('meta[name="csrf-token"]')?.content;
if (csrf) form.set("csrf", csrf);
// Preserve the server-issued, strictly validated project continuation from
// a status-mail capability URL across the CAPTCHA form POST.
void fetcher.submit(form, { method: "post", action: `${location.pathname}${location.search}` });
};
const privacyNoticeVersion = vm.status === "ready" ? vm.data.legalLinks.privacyUrl : vm.status;
return (
<CustomerPortalAuthPage
key={`${location.pathname}:${privacyNoticeVersion}`}
vm={vm}
brandingLogoHref={brandingLogoHref}
busy={fetcher.state !== "idle"}
errorKey={errorKey}
captcha={<Captcha enabled provider={captcha.provider} instanceUrl={captcha.instanceUrl} sitekey={captcha.sitekey} />}
actions={{
onSubmit: submit,
onBackToLogin: () => {
if (vm.status === "ready") navigate(vm.data.loginHref);
},
onForgotPassword: () => {
if (vm.status === "ready" && vm.data.passwordHref) navigate(vm.data.passwordHref);
},
}}
/>
);
}
function parseAuthDescriptor(rawPath: string): AuthDescriptor {
const path = rawPath.replace(/^\/+|\/+$/gu, "");
if (path === "login") return { mode: "login", token: null, purpose: null };
if (path === "login/magic-sent") return { mode: "magic_sent", token: null, purpose: null };
if (path === "forgot-password") return { mode: "forgot_password", token: null, purpose: null };
const match = /^(login\/magic|setup|verify-email|reset-password)\/([A-Za-z0-9_-]{43})$/u.exec(path);
if (!match) {
if (/^(login\/magic|setup|verify-email|reset-password)\//u.test(path)) {
return { mode: "invalid_token", token: null, purpose: null };
}
throw portalNotFound();
}
const token = match[2]!;
if (match[1] === "login/magic") return { mode: "magic_link", token, purpose: "magic_link" };
if (match[1] === "setup") return { mode: "setup", token, purpose: "setup" };
if (match[1] === "verify-email") return { mode: "verify_email", token, purpose: "verify_email" };
return { mode: "reset_password", token, purpose: "reset_password" };
}
function getAuthSecurityHeaders(descriptor: AuthDescriptor) {
return {
"Cache-Control": "no-store",
...(descriptor.token ? { "Referrer-Policy": "no-referrer" } : {}),
};
}
function resolveAuthPath(request: Request, wildcardPath: string | undefined, customHost: boolean): string {
if (!customHost) return wildcardPath ?? "";
return new URL(request.url).pathname.replace(/\.data$/u, "").replace(/^\/+|\/+$/gu, "");
}
function requirePortalLegalLinks(value: unknown): PortalLegalLinks {
if (!value || typeof value !== "object") throw portalNotFound();
const candidate = value as { readonly imprintUrl?: unknown; readonly privacyUrl?: unknown; readonly termsUrl?: unknown };
if (typeof candidate.imprintUrl !== "string" || !candidate.imprintUrl.trim()) throw portalNotFound();
if (typeof candidate.privacyUrl !== "string" || !candidate.privacyUrl.trim()) throw portalNotFound();
if (candidate.termsUrl !== null && typeof candidate.termsUrl !== "string") throw portalNotFound();
return {
imprintUrl: candidate.imprintUrl,
privacyUrl: candidate.privacyUrl,
termsUrl: candidate.termsUrl,
};
}
function stringValue(value: FormDataEntryValue | null): string | null {
return typeof value === "string" ? value : null;
}
function optionalBooleanValue(value: FormDataEntryValue | null): boolean | undefined {
const normalized = stringValue(value);
return normalized === null ? undefined : normalized === "true";
}
@@ -0,0 +1,133 @@
// @vitest-environment jsdom
import "@testing-library/jest-dom/vitest";
import { render, screen, waitFor } from "@testing-library/react";
import { buildPortalAuthVM, type PortalAuthVM } from "@hivegrid/view-models";
import { beforeEach, describe, expect, it, vi } from "vitest";
type AuthPageProps = {
readonly vm: PortalAuthVM;
readonly errorKey?: string | null;
};
const mocks = vi.hoisted(() => ({
loaderData: undefined as unknown,
location: { pathname: "/__portal/acme/setup/token", search: "" },
navigate: vi.fn(),
revalidate: vi.fn(),
pageProps: undefined as AuthPageProps | undefined,
mountSerial: 0,
fetcher: {
data: undefined as unknown,
state: "idle" as "idle" | "loading" | "submitting",
submit: vi.fn(),
},
}));
vi.mock("react-router", async (importOriginal) => {
const actual = await importOriginal<typeof import("react-router")>();
return {
...actual,
useLoaderData: () => mocks.loaderData,
useFetcher: () => mocks.fetcher,
useLocation: () => mocks.location,
useNavigate: () => mocks.navigate,
useRevalidator: () => ({ revalidate: mocks.revalidate }),
};
});
vi.mock("~/components/captcha/Captcha", () => ({ default: () => null }));
vi.mock("~/components/screens/customer-portal/CustomerPortalInterimPages", async () => {
const { useState } = await import("react");
return {
CustomerPortalAuthPage: (props: AuthPageProps) => {
const [instance] = useState(() => ++mocks.mountSerial);
mocks.pageProps = props;
return <output data-testid="auth-page-instance">{instance}</output>;
},
};
});
vi.mock("~/services/customer-portal/portal-auth-flow.server", () => ({
consumePortalCapability: vi.fn(),
requestPortalPasswordReset: vi.fn(),
requestPortalSignInLink: vi.fn(),
signInPortalWithPassword: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-capability-continue.server", () => ({ readPortalProjectContinuePath: vi.fn() }));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({ validatePortalCsrfToken: vi.fn() }));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
portalNotFound: () => new Response(null, { status: 404 }),
requirePortalTenantFromRequest: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-session-cookie.server", () => ({ serializePortalSessionCookie: vi.fn() }));
vi.mock("~/services/customer-portal/portal-origin.server", () => ({
portalPublicPath: vi.fn(),
requireTrustedPortalOrigin: vi.fn(),
}));
import CustomerPortalAuthRoute from "./auth";
function loaderData(privacyUrl: string) {
return {
vm: buildPortalAuthVM({
tenantSlug: "acme",
tenantName: "Acme GmbH",
portalName: "Acme Portal",
legalLinks: {
imprintUrl: "https://acme.example.test/imprint",
privacyUrl,
termsUrl: null,
},
mode: "setup",
allowPassword: false,
captchaRequired: true,
loginHref: "/acme/login",
supportEmail: "support@example.test",
}),
captcha: {
provider: "mcaptcha" as const,
instanceUrl: "https://captcha.example.test",
sitekey: "site-key",
},
};
}
describe("customer portal auth route privacy notice refresh", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.fetcher.data = undefined;
mocks.fetcher.state = "idle";
mocks.loaderData = loaderData("https://acme.example.test/privacy-v1");
mocks.pageProps = undefined;
mocks.mountSerial = 0;
});
it("reloads the canonical notice once and remounts the setup form when its URL changed", async () => {
const view = render(<CustomerPortalAuthRoute />);
const firstInstance = screen.getByTestId("auth-page-instance").textContent;
mocks.fetcher.data = { errorKey: "customerPortal.auth.errors.privacyNoticeChanged" };
view.rerender(<CustomerPortalAuthRoute />);
await waitFor(() => expect(mocks.revalidate).toHaveBeenCalledTimes(1));
expect(mocks.pageProps?.errorKey).toBe("customerPortal.auth.errors.privacyNoticeChanged");
mocks.loaderData = loaderData("https://acme.example.test/privacy-v2");
view.rerender(<CustomerPortalAuthRoute />);
expect(screen.getByTestId("auth-page-instance")).not.toHaveTextContent(firstInstance ?? "");
expect(mocks.pageProps?.vm.status).toBe("ready");
if (mocks.pageProps?.vm.status === "ready") {
expect(mocks.pageProps.vm.data.legalLinks.privacyUrl).toBe("https://acme.example.test/privacy-v2");
}
view.rerender(<CustomerPortalAuthRoute />);
expect(mocks.revalidate).toHaveBeenCalledTimes(1);
});
it("does not reload the loader for unrelated authentication errors", () => {
const view = render(<CustomerPortalAuthRoute />);
mocks.fetcher.data = { errorKey: "customerPortal.auth.errors.invalidToken" };
view.rerender(<CustomerPortalAuthRoute />);
expect(mocks.revalidate).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,66 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
createDownloadUrl: vi.fn(),
requireTenant: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-branding.server", () => ({
createPortalBrandingLogoDownloadUrl: mocks.createDownloadUrl,
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalTenantFromRequest: mocks.requireTenant,
portalNotFound: () => new Response(null, { status: 404, headers: { "Cache-Control": "no-store" } }),
}));
import { loader } from "./branding-logo";
const STANDARD_REQUEST = new Request("https://portal.example.test/acme/branding/logo");
const CUSTOM_REQUEST = new Request("https://portal.acme.test/branding/logo");
function call(request: Request, tenant?: string) {
return loader({ request, params: tenant === undefined ? {} : { tenant }, context: {} });
}
describe("customer portal branding logo route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireTenant.mockResolvedValue({ tenantId: "tenant_acme", tenantSlug: "acme" });
mocks.createDownloadUrl.mockResolvedValue("https://objects.example.test/private-logo?signature=redacted");
});
it("resolves the standard-host tenant before redirecting to a short-lived signed object", async () => {
const response = await call(STANDARD_REQUEST, "acme");
expect(mocks.requireTenant).toHaveBeenCalledWith(STANDARD_REQUEST, "acme");
expect(mocks.createDownloadUrl).toHaveBeenCalledWith("tenant_acme");
expect(response.status).toBe(302);
expect(response.headers.get("location")).toBe("https://objects.example.test/private-logo?signature=redacted");
expect(response.headers.get("cache-control")).toBe("private, no-store");
expect(response.headers.get("referrer-policy")).toBe("no-referrer");
expect(response.headers.get("x-content-type-options")).toBe("nosniff");
});
it("supports the slugless custom-host route through the same trusted resolver", async () => {
const response = await call(CUSTOM_REQUEST);
expect(mocks.requireTenant).toHaveBeenCalledWith(CUSTOM_REQUEST, undefined);
expect(mocks.createDownloadUrl).toHaveBeenCalledWith("tenant_acme");
expect(response.status).toBe(302);
});
it("preserves the resolver's indistinguishable 404 and never signs an unknown tenant", async () => {
mocks.requireTenant.mockRejectedValueOnce(new Response(null, { status: 404 }));
await expect(call(STANDARD_REQUEST, "unknown")).rejects.toMatchObject({ status: 404 });
expect(mocks.createDownloadUrl).not.toHaveBeenCalled();
});
it("fails closed with 404 when private-object signing is unavailable", async () => {
mocks.createDownloadUrl.mockRejectedValueOnce(new Error("storage unavailable"));
await expect(call(STANDARD_REQUEST, "acme")).rejects.toMatchObject({ status: 404 });
});
});
@@ -0,0 +1,25 @@
import { redirect, type LoaderFunctionArgs } from "react-router";
import { createPortalBrandingLogoDownloadUrl } from "~/services/customer-portal/portal-branding.server";
import { portalNotFound, requirePortalTenantFromRequest } from "~/services/customer-portal/portal-data.server";
const BRANDING_REDIRECT_HEADERS = {
"Cache-Control": "private, no-store",
"Referrer-Policy": "no-referrer",
"X-Content-Type-Options": "nosniff",
} as const;
/**
* Works for both route trees: `params.tenant` is present on the standard host
* and deliberately absent on a verified custom host. The trusted host boundary
* resolves either shape to exactly one tenant before a storage key is signed.
*/
export async function loader({ request, params }: LoaderFunctionArgs) {
const tenant = await requirePortalTenantFromRequest(request, params.tenant);
try {
const signedUrl = await createPortalBrandingLogoDownloadUrl(tenant.tenantId);
return redirect(signedUrl, { status: 302, headers: BRANDING_REDIRECT_HEADERS });
} catch {
throw portalNotFound();
}
}
@@ -0,0 +1,95 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
dashboardLoader: vi.fn(),
projectsLoader: vi.fn(),
settingsAction: vi.fn(),
}));
vi.mock("./dashboard", () => ({ loader: mocks.dashboardLoader }));
vi.mock("./projects", () => ({ loader: mocks.projectsLoader }));
vi.mock("./settings", () => ({ action: mocks.settingsAction }));
import { finalizePortalHostRoutingDecision, getHostRoutingRuntimeDecision } from "../../../../../server/host-routing-runtime";
import { prepareReactRouterManifestRequest } from "../../../../../server/react-router-manifest-dispatch";
import { dispatchPortalAction, dispatchPortalLoader } from "./custom-host-dispatch.server";
const routing = {
appBaseDomain: "hivegrid.de",
webAppHost: "app.hivegrid.de",
adminAppHost: "admin.hivegrid.de",
apiHost: "api.hivegrid.de",
portalAppHost: "portal.hivegrid.de",
protocol: "https" as const,
};
describe("host-aware customer portal route dispatch", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.dashboardLoader.mockResolvedValue(Response.json({ target: "dashboard" }));
mocks.projectsLoader.mockResolvedValue(Response.json({ target: "projects" }));
mocks.settingsAction.mockImplementation(async ({ request }) => Response.json({ body: await request.text() }));
});
it("preserves a standard-host tenant whose slug collides with a custom alias", async () => {
const response = await dispatchPortalLoader({
request: new Request("https://portal.hivegrid.de/projects", {
headers: {
"x-hivegrid-portal-tenant": "projects",
"x-hivegrid-portal-origin": "https://portal.hivegrid.de",
},
}),
params: {},
context: {},
} as never);
await expect(response.json()).resolves.toEqual({ target: "dashboard" });
expect(mocks.dashboardLoader).toHaveBeenCalledWith(expect.objectContaining({ params: { tenant: "projects" } }));
expect(mocks.projectsLoader).not.toHaveBeenCalled();
});
it("interprets the same public path as the project list on a custom host", async () => {
const response = await dispatchPortalLoader({
request: new Request("https://kunden.example.org/projects", {
headers: {
"x-hivegrid-portal-tenant": "projects",
"x-hivegrid-portal-origin": "https://kunden.example.org",
"x-hivegrid-portal-custom-host": "kunden.example.org",
},
}),
params: {},
context: {},
} as never);
await expect(response.json()).resolves.toEqual({ target: "projects" });
expect(mocks.projectsLoader).toHaveBeenCalledWith(expect.objectContaining({ params: {} }));
expect(mocks.dashboardLoader).not.toHaveBeenCalled();
});
it("preserves a custom settings data mutation body across both routing boundaries", async () => {
const outer = getHostRoutingRuntimeDecision(
new Request("https://kunden.example.org/settings.data?_routes=routes%2Fcustomer-portal%2Fsettings.__custom-host", {
method: "POST",
headers: { "content-type": "application/x-www-form-urlencoded" },
body: "intent=request_export",
}),
{ runtimeSurface: "portal", routing }
);
if (outer.type !== "resolve-portal-host") throw new Error("expected custom-host resolution");
const resolved = finalizePortalHostRoutingDecision(outer, {
hostname: "kunden.example.org",
tenantSlug: "projects",
activeOrigin: "https://kunden.example.org",
});
if (resolved.type !== "dispatch") throw new Error("expected custom-host dispatch");
const manifest = prepareReactRouterManifestRequest(resolved.request, "portal");
if (manifest.type !== "dispatch") throw new Error("expected portal manifest dispatch");
const response = await dispatchPortalAction({ request: manifest.request, params: {}, context: {} } as never);
await expect(response.json()).resolves.toEqual({ body: "intent=request_export" });
expect(mocks.settingsAction).toHaveBeenCalledWith(expect.objectContaining({ params: {} }));
});
});
@@ -0,0 +1,60 @@
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { resolvePortalRouteDispatch, type PortalRouteTarget } from "~/services/customer-portal/portal-route-dispatch";
const PORTAL_CUSTOM_HOST_HEADER = "x-hivegrid-portal-custom-host";
export async function dispatchPortalLoader(args: LoaderFunctionArgs) {
const resolved = requireDispatch(args.request);
const delegated = { ...args, params: resolved.params } as LoaderFunctionArgs;
switch (resolved.target) {
case "auth":
return (await import("./auth")).loader(delegated);
case "dashboard":
return (await import("./dashboard")).loader(delegated);
case "document-download":
return (await import("./document-download")).loader(delegated);
case "export-download":
return (await import("./export-download")).loader(delegated);
case "logout":
return (await import("./logout")).loader(delegated);
case "project-complaint":
return (await import("./project-complaint")).loader(delegated);
case "project-detail":
return (await import("./project-detail")).loader(delegated);
case "project-upload":
return (await import("./project-upload")).loader(delegated);
case "projects":
return (await import("./projects")).loader(delegated);
case "settings":
return (await import("./settings")).loader(delegated);
case "upload":
return (await import("./upload")).loader(delegated);
}
}
export async function dispatchPortalAction(args: ActionFunctionArgs) {
const resolved = requireDispatch(args.request);
const delegated = { ...args, params: resolved.params } as ActionFunctionArgs;
switch (resolved.target) {
case "auth":
return (await import("./auth")).action(delegated);
case "logout":
return (await import("./logout")).action(delegated);
case "project-complaint":
return (await import("./project-complaint")).action(delegated);
case "project-upload":
return (await import("./project-upload")).action(delegated);
case "settings":
return (await import("./settings")).action(delegated);
default:
throw new Response(null, { status: 404, headers: { "Cache-Control": "no-store" } });
}
}
function requireDispatch(request: Request): { readonly target: PortalRouteTarget; readonly params: Readonly<Record<string, string | undefined>> } {
const customHost = Boolean(request.headers.get(PORTAL_CUSTOM_HOST_HEADER)?.trim());
const resolved = resolvePortalRouteDispatch(new URL(request.url).pathname, customHost);
if (!resolved) throw new Response(null, { status: 404, headers: { "Cache-Control": "no-store" } });
return resolved;
}
@@ -0,0 +1,44 @@
import { useLocation, useRouteLoaderData, type ActionFunctionArgs, type LoaderFunctionArgs } from "react-router";
import type { PortalRootData } from "~/services/customer-portal/portal-root";
import { resolvePortalRouteDispatch } from "~/services/customer-portal/portal-route-dispatch";
import CustomerPortalAuthRoute from "./auth";
import CustomerPortalDashboardRoute from "./dashboard";
import CustomerPortalProjectDetailRoute from "./project-detail";
import CustomerPortalProjectsRoute from "./projects";
import CustomerPortalSettingsRoute from "./settings";
import CustomerPortalUploadRoute from "./upload";
export async function loader(args: LoaderFunctionArgs) {
const { dispatchPortalLoader } = await import("./custom-host-dispatch.server");
return dispatchPortalLoader(args);
}
export async function action(args: ActionFunctionArgs) {
const { dispatchPortalAction } = await import("./custom-host-dispatch.server");
return dispatchPortalAction(args);
}
export default function CustomerPortalHostAwareDispatchRoute() {
const root = useRouteLoaderData<PortalRootData>("root");
const location = useLocation();
const resolved = resolvePortalRouteDispatch(location.pathname, root?.customHost === true);
if (!resolved) throw new Response(null, { status: 404 });
switch (resolved.target) {
case "auth":
return <CustomerPortalAuthRoute />;
case "dashboard":
return <CustomerPortalDashboardRoute />;
case "project-detail":
return <CustomerPortalProjectDetailRoute />;
case "projects":
return <CustomerPortalProjectsRoute />;
case "settings":
return <CustomerPortalSettingsRoute />;
case "upload":
return <CustomerPortalUploadRoute />;
default:
return null;
}
}
@@ -0,0 +1,68 @@
import { buildPortalDashboardVM } from "@hivegrid/view-models";
import { useFetcher, useLoaderData, useNavigate, useRouteLoaderData, type LoaderFunctionArgs } from "react-router";
import { CustomerPortalDashboardPage } from "~/components/screens/customer-portal/CustomerPortalInterimPages";
import { loadPortalProjectDataset, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import type { PortalRootData } from "~/services/customer-portal/portal-root";
import { portalPublicPath } from "~/services/customer-portal/portal-origin.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const session = await requirePortalSessionContext(request, params.tenant);
const { identity } = session;
const baseHref = portalPublicPath(session.origin);
const dataset = await loadPortalProjectDataset(identity, undefined, baseHref);
const paths = {
dashboard: baseHref,
projects: portalPublicPath(session.origin, "projects"),
upload: portalPublicPath(session.origin, "upload"),
settings: portalPublicPath(session.origin, "settings"),
logout: portalPublicPath(session.origin, "logout"),
};
const data = {
vm: buildPortalDashboardVM({
portalName: identity.portalTitle,
viewerLabel: viewerLabel(identity),
frozen: identity.tenantFrozen,
projects: dataset.projects,
projectsHref: paths.projects,
logoutAction: paths.logout,
buildProjectHref: (projectId) => portalPublicPath(session.origin, `projects/${projectId}`),
locale: identity.viewerLocale,
}),
brandingLogoHref: portalPublicPath(session.origin, "branding/logo"),
paths,
};
const responseHeaders = new Headers(session.responseHeaders);
responseHeaders.set("Cache-Control", "private, no-store");
return Response.json(data, { headers: responseHeaders });
}
export default function CustomerPortalDashboardRoute() {
const { vm, brandingLogoHref, paths } = useLoaderData<typeof loader>();
const root = useRouteLoaderData<PortalRootData>("root");
const navigate = useNavigate();
const logout = useFetcher();
return (
<CustomerPortalDashboardPage
vm={vm}
brandingLogoHref={brandingLogoHref}
actions={{
onDashboard: () => navigate(paths.dashboard),
onProjects: () => navigate(paths.projects),
onUpload: () => navigate(paths.upload),
onSettings: () => navigate(paths.settings),
onOpenProject: (href) => navigate(href),
onDownloadDocument: (href) => window.location.assign(href),
onLogout: () => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
void logout.submit(form, { method: "post", action: paths.logout });
},
}}
/>
);
}
function viewerLabel(identity: { viewerFirstName: string; viewerLastName: string; portalTitle: string }): string {
return `${identity.viewerFirstName} ${identity.viewerLastName}`.trim() || identity.portalTitle;
}
@@ -0,0 +1,110 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
requireIdentity: vi.fn(),
getReleasedFile: vi.fn(),
createDownloadUrl: vi.fn(),
assertTenantKey: vi.fn(),
auditDownload: vi.fn(),
recordDownload: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireIdentity,
getPortalReleasedFile: mocks.getReleasedFile,
auditPortalDocumentDownload: mocks.auditDownload,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/utils/integrations/mediaSigning.server", () => ({ createMediaDownloadUrl: mocks.createDownloadUrl }));
vi.mock("~/lib/metrics/storage-traffic", () => ({ recordAuthorizedStorageDownload: mocks.recordDownload }));
vi.mock("@hivegrid/storage", async (importOriginal) => ({
...(await importOriginal<typeof import("@hivegrid/storage")>()),
assertFileKeyBelongsToTenant: mocks.assertTenantKey,
}));
import { loader } from "./document-download";
const identity = { tenantId: "tenant-a", tenantSlug: "acme" };
const cleanFile = {
storageKey: "tenants/tenant-a/files/release.pdf",
displayName: "Freigabe.pdf",
scanStatus: "clean",
};
describe("customer portal document download", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireIdentity.mockResolvedValue({ identity, responseHeaders: { "Cache-Control": "private, no-store" } });
mocks.getReleasedFile.mockResolvedValue(cleanFile);
mocks.createDownloadUrl.mockResolvedValue("https://objects.example.test/signed");
mocks.auditDownload.mockResolvedValue(undefined);
});
it("signs only a clean, tenant-owned released file", async () => {
await expect(
loader({
request: new Request("https://portal.hivegrid.test/acme/documents/release-a"),
params: { tenant: "acme", releaseId: "release-a" },
context: {},
})
).rejects.toMatchObject({ status: 302 });
expect(mocks.assertTenantKey).toHaveBeenCalledWith("tenant-a", cleanFile.storageKey, "download");
expect(mocks.createDownloadUrl).toHaveBeenCalledWith({
key: cleanFile.storageKey,
filename: cleanFile.displayName,
ttlSeconds: 60,
});
expect(mocks.auditDownload).toHaveBeenCalledWith(identity, "release-a", expect.any(Request));
expect(mocks.auditDownload.mock.invocationCallOrder[0]).toBeGreaterThan(mocks.createDownloadUrl.mock.invocationCallOrder[0] ?? Number.MAX_SAFE_INTEGER);
expect(mocks.recordDownload).toHaveBeenCalledWith({
surface: "portal_document",
delivery: "signed_redirect",
objectSizeBytes: null,
});
expect(mocks.recordDownload.mock.invocationCallOrder[0]).toBeGreaterThan(mocks.auditDownload.mock.invocationCallOrder[0] ?? Number.MAX_SAFE_INTEGER);
});
it.each(["pending", "infected", "error"])("returns 404 for a %s scanner verdict", async (scanStatus) => {
mocks.getReleasedFile.mockResolvedValue({ ...cleanFile, scanStatus });
await expect(
loader({
request: new Request("https://portal.hivegrid.test/acme/documents/release-a"),
params: { tenant: "acme", releaseId: "release-a" },
context: {},
})
).rejects.toMatchObject({ status: 404 });
expect(mocks.createDownloadUrl).not.toHaveBeenCalled();
expect(mocks.auditDownload).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
});
it("returns 404 when the storage key does not belong to the tenant", async () => {
mocks.assertTenantKey.mockImplementationOnce(() => {
throw new Error("foreign key");
});
await expect(
loader({
request: new Request("https://portal.hivegrid.test/acme/documents/release-a"),
params: { tenant: "acme", releaseId: "release-a" },
context: {},
})
).rejects.toMatchObject({ status: 404 });
expect(mocks.createDownloadUrl).not.toHaveBeenCalled();
expect(mocks.auditDownload).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
});
it("does not count a URL whose required audit write fails before delivery", async () => {
mocks.auditDownload.mockRejectedValueOnce(new Error("audit unavailable"));
await expect(
loader({
request: new Request("https://portal.hivegrid.test/acme/documents/release-a"),
params: { tenant: "acme", releaseId: "release-a" },
context: {},
})
).rejects.toThrow("audit unavailable");
expect(mocks.recordDownload).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,24 @@
import { redirect, type LoaderFunctionArgs } from "react-router";
import { assertFileKeyBelongsToTenant } from "@hivegrid/storage";
import { auditPortalDocumentDownload, getPortalReleasedFile, portalNotFound, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import { isFileScanDeliverable } from "~/utils/integrations/fileScanPolicy";
import { createMediaDownloadUrl } from "~/utils/integrations/mediaSigning.server";
import { recordAuthorizedStorageDownload } from "~/lib/metrics/storage-traffic";
export async function loader({ request, params }: LoaderFunctionArgs) {
if (!params.releaseId) throw portalNotFound();
const session = await requirePortalSessionContext(request, params.tenant);
const { identity } = session;
const file = await getPortalReleasedFile(identity, params.releaseId);
if (!file || !isFileScanDeliverable(file.scanStatus)) throw portalNotFound();
try {
assertFileKeyBelongsToTenant(identity.tenantId, file.storageKey, "download");
} catch {
throw portalNotFound();
}
const signedUrl = await createMediaDownloadUrl({ key: file.storageKey, filename: file.displayName, ttlSeconds: 60 });
await auditPortalDocumentDownload(identity, params.releaseId, request);
recordAuthorizedStorageDownload({ surface: "portal_document", delivery: "signed_redirect", objectSizeBytes: null });
throw redirect(signedUrl, { headers: session.responseHeaders });
}
@@ -0,0 +1,196 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
requireSession: vi.fn(),
resolveDownload: vi.fn(),
recordDownload: vi.fn(),
assertTenantKey: vi.fn(),
readObject: vi.fn(),
resolveBucket: vi.fn(),
acquireGate: vi.fn(),
holdGate: vi.fn((response: Response) => response),
releaseGate: vi.fn(),
}));
vi.mock("@hivegrid/config", async (importOriginal) => ({
...(await importOriginal<typeof import("@hivegrid/config")>()),
loadRequiredWebConfig: () => ({ portalSessionSecret: "portal-session-secret-with-at-least-32-bytes" }),
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireSession,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/services/customer-portal/portal-lifecycle.server", () => ({
resolvePortalGdprExportArtifact: mocks.resolveDownload,
recordPortalGdprExportDownload: mocks.recordDownload,
}));
vi.mock("@hivegrid/storage", async (importOriginal) => ({
...(await importOriginal<typeof import("@hivegrid/storage")>()),
assertGdprExportArtifactKey: mocks.assertTenantKey,
}));
vi.mock("~/utils/integrations/storageService", () => ({ resolveStorageBucket: mocks.resolveBucket }));
vi.mock("~/utils/privacy/gdprExportDownload.server", async (importOriginal) => ({
...(await importOriginal<typeof import("~/utils/privacy/gdprExportDownload.server")>()),
readGdprExportObject: mocks.readObject,
}));
vi.mock("~/utils/privacy/gdprExportDownloadGate.server", () => ({
acquireGdprExportDownloadGate: mocks.acquireGate,
holdGdprExportDownloadGateUntilResponseFinished: mocks.holdGate,
}));
import { loader } from "./export-download";
const session = {
identity: { tenantId: "tenant-a", portalUserId: "portal-user-a" },
responseHeaders: new Headers({ "Set-Cookie": "portal=renewed" }),
};
function args(method = "GET") {
return {
request: new Request("https://portal.example.test/acme/exports/export-a", { method }),
params: { tenant: "acme", exportId: "export-a" },
context: {},
};
}
describe("customer portal GDPR export download", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireSession.mockResolvedValue(session);
const artifact = {
resultBucket: "portal-private",
resultKey: "gdpr-exports/portal/tenants/tenant-a/export-a/attempt-a.json",
resultSizeBytes: 512,
resultExpiresAt: new Date("2099-07-17T08:00:00.000Z"),
};
mocks.resolveDownload.mockResolvedValue(artifact);
mocks.recordDownload.mockResolvedValue(artifact);
mocks.resolveBucket.mockReturnValue("portal-private");
mocks.acquireGate.mockResolvedValue({ release: mocks.releaseGate });
mocks.holdGate.mockImplementation((response: Response) => response);
mocks.releaseGate.mockResolvedValue(undefined);
mocks.readObject.mockResolvedValue({
body: new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode('{"ok":true}'));
controller.close();
},
}),
contentLength: 11,
});
});
it("uses the narrow lifecycle capability and returns a server-proxied encrypted object", async () => {
const response = await loader(args());
expect(response.status).toBe(200);
expect(response.headers.get("Location")).toBeNull();
expect(response.headers.get("Content-Type")).toBe("application/json");
expect(response.headers.get("Content-Disposition")).toBe('attachment; filename="hivegrid-datenauskunft.json"');
expect(response.headers.get("Cache-Control")).toBe("private, no-store");
expect(response.headers.get("X-Content-Type-Options")).toBe("nosniff");
expect(response.headers.get("Set-Cookie")).toBe("portal=renewed");
expect(mocks.releaseGate).not.toHaveBeenCalled();
await expect(response.text()).resolves.toBe('{"ok":true}');
expect(mocks.recordDownload).toHaveBeenCalledWith(session, {
exportId: "export-a",
request: expect.any(Request),
});
expect(mocks.resolveDownload).toHaveBeenCalledWith(session, { exportId: "export-a" });
expect(mocks.acquireGate).toHaveBeenCalledWith({
scope: "portal",
tenantId: "tenant-a",
principalId: "portal-user-a",
artifactId: "export-a",
secret: "portal-session-secret-with-at-least-32-bytes",
});
expect(mocks.acquireGate.mock.invocationCallOrder[0]).toBeLessThan(mocks.readObject.mock.invocationCallOrder[0]!);
expect(mocks.readObject.mock.invocationCallOrder[0]).toBeLessThan(mocks.recordDownload.mock.invocationCallOrder[0]!);
expect(mocks.holdGate).toHaveBeenCalledWith(expect.any(Response), { release: mocks.releaseGate });
expect(mocks.assertTenantKey).toHaveBeenCalledWith({
tenantId: "tenant-a",
exportJobId: "export-a",
key: "gdpr-exports/portal/tenants/tenant-a/export-a/attempt-a.json",
scope: "portal",
});
expect(mocks.readObject).toHaveBeenCalledWith({
bucket: "portal-private",
key: "gdpr-exports/portal/tenants/tenant-a/export-a/attempt-a.json",
maxBytes: 16 * 1024 * 1024,
expectedSizeBytes: 512,
signal: expect.any(AbortSignal),
});
});
it("rejects HEAD before session, storage, counting or audit work", async () => {
await expect(loader(args("HEAD"))).rejects.toMatchObject({ status: 404 });
expect(mocks.requireSession).not.toHaveBeenCalled();
expect(mocks.resolveDownload).not.toHaveBeenCalled();
expect(mocks.readObject).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
expect(mocks.acquireGate).not.toHaveBeenCalled();
});
it("maps a busy or unavailable distributed gate to the same non-disclosing 404 before storage", async () => {
mocks.acquireGate.mockResolvedValueOnce(null);
await expect(loader(args())).rejects.toMatchObject({ status: 404 });
expect(mocks.resolveDownload).not.toHaveBeenCalled();
expect(mocks.readObject).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
});
it("fails closed when the stored bucket differs from the configured private bucket", async () => {
mocks.resolveDownload.mockResolvedValueOnce({
resultBucket: "foreign-bucket",
resultKey: "tenants/tenant-a/portal-gdpr/export-a.json",
resultSizeBytes: 512,
resultExpiresAt: new Date("2099-07-17T08:00:00.000Z"),
});
await expect(loader(args())).rejects.toMatchObject({ status: 404 });
expect(mocks.assertTenantKey).not.toHaveBeenCalled();
expect(mocks.readObject).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
expect(mocks.releaseGate).toHaveBeenCalledTimes(1);
});
it("fails closed when the artifact key belongs to another tenant", async () => {
mocks.assertTenantKey.mockImplementationOnce(() => {
throw new Error("foreign tenant key");
});
await expect(loader(args())).rejects.toMatchObject({ status: 404 });
expect(mocks.readObject).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
expect(mocks.releaseGate).toHaveBeenCalledTimes(1);
});
it("returns 404 for a tenant-B session before storage, download counting or audit", async () => {
const tenantBSession = {
...session,
identity: { tenantId: "tenant-b", portalUserId: "portal-user-b" },
};
mocks.requireSession.mockResolvedValueOnce(tenantBSession);
mocks.resolveDownload.mockRejectedValueOnce(new Error("tenant-scoped export not found"));
await expect(loader(args())).rejects.toMatchObject({ status: 404 });
expect(mocks.resolveDownload).toHaveBeenCalledWith(tenantBSession, { exportId: "export-a" });
expect(mocks.acquireGate).toHaveBeenCalledWith({
scope: "portal",
tenantId: "tenant-b",
principalId: "portal-user-b",
artifactId: "export-a",
secret: "portal-session-secret-with-at-least-32-bytes",
});
expect(mocks.assertTenantKey).not.toHaveBeenCalled();
expect(mocks.readObject).not.toHaveBeenCalled();
expect(mocks.recordDownload).not.toHaveBeenCalled();
expect(mocks.releaseGate).toHaveBeenCalledTimes(1);
});
it("fails closed when the encrypted object cannot be read", async () => {
mocks.readObject.mockRejectedValueOnce(new Error("SSE-C key mismatch"));
await expect(loader(args())).rejects.toMatchObject({ status: 404 });
expect(mocks.recordDownload).not.toHaveBeenCalled();
expect(mocks.releaseGate).toHaveBeenCalledTimes(1);
});
});
@@ -0,0 +1,54 @@
import type { LoaderFunctionArgs } from "react-router";
import { loadRequiredWebConfig } from "@hivegrid/config";
import { assertGdprExportArtifactKey } from "@hivegrid/storage";
import { portalNotFound, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import { recordPortalGdprExportDownload, resolvePortalGdprExportArtifact } from "~/services/customer-portal/portal-lifecycle.server";
import { resolveStorageBucket } from "~/utils/integrations/storageService";
import { createGdprExportDownloadResponse, PORTAL_GDPR_EXPORT_DOWNLOAD_MAX_BYTES, readGdprExportObject } from "~/utils/privacy/gdprExportDownload.server";
import { acquireGdprExportDownloadGate, holdGdprExportDownloadGateUntilResponseFinished } from "~/utils/privacy/gdprExportDownloadGate.server";
export async function loader({ request, params }: LoaderFunctionArgs): Promise<Response> {
if (request.method !== "GET") throw portalNotFound();
if (!params.exportId) throw portalNotFound();
const session = await requirePortalSessionContext(request, params.tenant);
try {
const gate = await acquireGdprExportDownloadGate({
scope: "portal",
tenantId: session.identity.tenantId,
principalId: session.identity.portalUserId,
artifactId: params.exportId,
secret: loadRequiredWebConfig().portalSessionSecret ?? "",
});
if (!gate) throw new Error("Portal export download gate denied the read.");
let gateHeldByResponse = false;
try {
const artifact = await resolvePortalGdprExportArtifact(session, { exportId: params.exportId });
if (artifact.resultBucket !== resolveStorageBucket()) throw new Error("Portal export bucket mismatch.");
assertGdprExportArtifactKey({ tenantId: session.identity.tenantId, exportJobId: params.exportId, key: artifact.resultKey, scope: "portal" });
const object = await readGdprExportObject({
bucket: artifact.resultBucket,
key: artifact.resultKey,
maxBytes: PORTAL_GDPR_EXPORT_DOWNLOAD_MAX_BYTES,
...(artifact.resultSizeBytes !== null ? { expectedSizeBytes: artifact.resultSizeBytes } : {}),
signal: request.signal,
});
await recordPortalGdprExportDownload(session, { exportId: params.exportId, request });
const response = holdGdprExportDownloadGateUntilResponseFinished(
createGdprExportDownloadResponse({
object,
filename: "hivegrid-datenauskunft.json",
contentType: "application/json",
headers: session.responseHeaders,
}),
gate,
);
gateHeldByResponse = true;
return response;
} finally {
if (!gateHeldByResponse) await gate.release();
}
} catch {
throw portalNotFound();
}
}
@@ -0,0 +1,13 @@
import { Outlet, type LoaderFunctionArgs } from "react-router";
import { isPortalRuntimeSurface } from "~/services/customer-portal/portal-root.server";
import { portalNotFound } from "~/services/customer-portal/portal-data.server";
export async function loader(_args: LoaderFunctionArgs) {
if (!isPortalRuntimeSurface()) throw portalNotFound();
return null;
}
export default function CustomerPortalLayout() {
return <Outlet />;
}
@@ -0,0 +1,47 @@
import { describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
validateCsrf: vi.fn(),
requireIdentity: vi.fn(),
revokeSession: vi.fn(),
clearCookie: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({
validatePortalCsrfToken: (...args: unknown[]) => mocks.validateCsrf(...args),
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
portalNotFound: () => new Response(null, { status: 404 }),
requirePortalSessionIdentity: (...args: unknown[]) => mocks.requireIdentity(...args),
revokePortalSession: (...args: unknown[]) => mocks.revokeSession(...args),
}));
vi.mock("~/services/customer-portal/portal-session-cookie.server", () => ({
clearPortalSessionCookie: (...args: unknown[]) => mocks.clearCookie(...args),
}));
import { action } from "./logout";
describe("customer portal logout", () => {
it("passes the authenticated request into the atomic revoke-and-audit boundary", async () => {
const identity = { tenantSlug: "acme", tenantId: "tenant_1", portalUserId: "portal_user_1", portalSessionId: "session_1" };
const request = new Request("https://portal.hivegrid.test/acme/logout", {
method: "POST",
headers: {
"content-type": "application/x-www-form-urlencoded",
"x-hivegrid-portal-origin": "https://portal.hivegrid.test",
"x-hivegrid-portal-tenant": "acme",
"x-request-id": "logout-request-1",
},
body: "csrf=token",
});
mocks.requireIdentity.mockResolvedValue(identity);
mocks.revokeSession.mockResolvedValue(undefined);
mocks.clearCookie.mockResolvedValue("__Host-hivegrid_portal_session=; Max-Age=0");
await expect(action({ request, params: { tenant: "acme" }, context: {} } as never)).rejects.toMatchObject({ status: 302 });
expect(mocks.validateCsrf).toHaveBeenCalledOnce();
expect(mocks.revokeSession).toHaveBeenCalledWith(identity, request);
expect(mocks.clearCookie).toHaveBeenCalledOnce();
});
});
@@ -0,0 +1,21 @@
import { redirect, type ActionFunctionArgs, type LoaderFunctionArgs } from "react-router";
import { validatePortalCsrfToken } from "~/services/customer-portal/portal-csrf.server";
import { portalNotFound, requirePortalSessionIdentity, revokePortalSession } from "~/services/customer-portal/portal-data.server";
import { clearPortalSessionCookie } from "~/services/customer-portal/portal-session-cookie.server";
import { portalPublicPath, requireTrustedPortalOrigin } from "~/services/customer-portal/portal-origin.server";
export async function loader(_args: LoaderFunctionArgs) {
throw portalNotFound();
}
export async function action({ request, params }: ActionFunctionArgs) {
const form = await request.clone().formData();
await validatePortalCsrfToken(request, form);
const identity = await requirePortalSessionIdentity(request, params.tenant);
const origin = requireTrustedPortalOrigin(request, identity.tenantSlug);
await revokePortalSession(identity, request);
throw redirect(portalPublicPath(origin, "login"), {
headers: { "Cache-Control": "no-store", "Set-Cookie": await clearPortalSessionCookie() },
});
}
@@ -0,0 +1,90 @@
// @vitest-environment jsdom
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => {
class PortalComplaintError extends Error {
constructor(readonly code: string) {
super(code);
}
}
return {
PortalComplaintError,
requireSession: vi.fn(),
validateCsrf: vi.fn(),
submitComplaint: vi.fn(),
};
});
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireSession,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({ validatePortalCsrfToken: mocks.validateCsrf }));
vi.mock("~/services/customer-portal/portal-complaint.server", () => ({
PortalComplaintError: mocks.PortalComplaintError,
submitPortalComplaint: mocks.submitComplaint,
}));
import { action } from "./project-complaint";
const session = {
identity: { tenantId: "tenant-a", portalUserId: "portal-user-a", tenantFrozen: false },
responseHeaders: new Headers({ "Set-Cookie": "portal=renewed" }),
};
function args(request: Request) {
return { request, params: { tenant: "acme", projectId: "project-a", formId: "form-a" }, context: {} } as never;
}
function complaintRequest(payload: string): Request {
const form = new FormData();
form.set("csrf", "csrf-token");
form.set("idempotencyKey", "complaint-key-a");
form.set("gdprAccepted", "true");
form.set("payload", payload);
const request = new Request("https://portal.example.test/acme/projects/project-a/complaints/form-a", { method: "POST" });
Object.defineProperty(request, "formData", { value: async () => form });
return request;
}
describe("customer portal complaint route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireSession.mockResolvedValue(session);
mocks.validateCsrf.mockResolvedValue(undefined);
mocks.submitComplaint.mockResolvedValue({ complaintId: "complaint-a", submissionId: "submission-a" });
});
it("submits the authenticated portal_form payload with GDPR proof and idempotency", async () => {
const request = complaintRequest(JSON.stringify({ subject: "Heizung bleibt kalt", urgent: true }));
const response = await action(args(request));
expect(response.status).toBe(201);
expect(mocks.validateCsrf).toHaveBeenCalledWith(request, expect.any(FormData));
expect(mocks.submitComplaint).toHaveBeenCalledWith({
identity: session.identity,
projectId: "project-a",
formId: "form-a",
payload: {
values: { subject: "Heizung bleibt kalt", urgent: true },
gdprAccepted: true,
idempotencyKey: "complaint-key-a",
},
});
await expect(response.json()).resolves.toMatchObject({ ok: true, complaintId: "complaint-a", messageKey: "customerPortal.complaint.success" });
});
it("rejects malformed JSON with a stable M002 key before persistence", async () => {
const response = await action(args(complaintRequest("{")));
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({ ok: false, errorKey: "customerPortal.complaint.errors.invalidPayload" });
expect(mocks.submitComplaint).not.toHaveBeenCalled();
});
it("maps unavailable forms and project access to a non-enumerating 404", async () => {
mocks.submitComplaint.mockRejectedValueOnce(new mocks.PortalComplaintError("FORM_NOT_FOUND"));
await expect(action(args(complaintRequest(JSON.stringify({ subject: "Hidden" }))))).rejects.toMatchObject({ status: 404 });
});
});
@@ -0,0 +1,60 @@
import type { ActionFunctionArgs } from "react-router";
import { validatePortalCsrfToken } from "~/services/customer-portal/portal-csrf.server";
import { PortalComplaintError, submitPortalComplaint } from "~/services/customer-portal/portal-complaint.server";
import { portalNotFound, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
const MAX_COMPLAINT_BYTES = 256 * 1024;
export async function action({ request, params }: ActionFunctionArgs): Promise<Response> {
if (request.method !== "POST" || !params.projectId || !params.formId) throw portalNotFound();
const contentLength = Number(request.headers.get("content-length") ?? "0");
if (Number.isFinite(contentLength) && contentLength > MAX_COMPLAINT_BYTES) return failure("customerPortal.complaint.errors.payloadTooLarge", 413);
const session = await requirePortalSessionContext(request, params.tenant);
const form = await request.formData();
await validatePortalCsrfToken(request, form);
let values: Record<string, string | number | boolean | readonly string[] | null>;
const rawPayload = form.get("payload");
try {
values = typeof rawPayload === "string" ? (JSON.parse(rawPayload) as typeof values) : complaintValuesFromForm(form);
} catch {
return failure("customerPortal.complaint.errors.invalidPayload", 400, session.responseHeaders);
}
try {
const created = await submitPortalComplaint({
identity: session.identity,
projectId: params.projectId,
formId: params.formId,
payload: {
values,
gdprAccepted: form.get("gdprAccepted") === "true" || form.get("gdprAccepted") === "on",
idempotencyKey: form.get("idempotencyKey")?.toString(),
},
});
return Response.json({ ok: true, ...created, messageKey: "customerPortal.complaint.success" }, { status: 201, headers: session.responseHeaders });
} catch (error) {
if (error instanceof PortalComplaintError) {
if (error.code === "PORTAL_FROZEN" || error.code === "PROJECT_ACCESS_DENIED" || error.code === "FORM_NOT_FOUND") throw portalNotFound();
return failure(`customerPortal.complaint.errors.${error.code}`, error.code === "SUBMISSION_FAILED" ? 503 : 422, session.responseHeaders);
}
return failure("customerPortal.complaint.errors.unavailable", 503, session.responseHeaders);
}
}
export async function loader(): Promise<never> {
throw portalNotFound();
}
function complaintValuesFromForm(form: FormData): Record<string, string | number | boolean | readonly string[] | null> {
const values: Record<string, string | number | boolean | readonly string[] | null> = {};
for (const [key, value] of form.entries()) {
if (["csrf", "gdprAccepted", "idempotencyKey", "payload"].includes(key) || value instanceof File) continue;
const all = form.getAll(key).filter((entry): entry is string => typeof entry === "string");
values[key] = all.length > 1 ? all : value;
}
return values;
}
function failure(errorKey: string, status: number, headers?: Headers): Response {
return Response.json({ ok: false, errorKey }, { status, headers });
}
@@ -0,0 +1,112 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const portalData = vi.hoisted(() => ({
requirePortalSessionContext: vi.fn(),
loadPortalProjectDataset: vi.fn(),
}));
const portalInteractions = vi.hoisted(() => ({
loadPortalProjectInteractionsVM: vi.fn(),
}));
vi.mock("~/components/screens/customer-portal/CustomerPortalInterimPages", () => ({
CustomerPortalProjectDetailPage: () => null,
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
...portalData,
portalNotFound: () => new Response(null, { status: 404, headers: { "Cache-Control": "no-store" } }),
}));
vi.mock("~/services/customer-portal/portal-interactions-data.server", () => portalInteractions);
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => `translated:${key}` })) }));
import { loader } from "./project-detail";
const identity = {
tenantId: "tenant-1",
portalId: "portal-1",
portalUserId: "portal-user-1",
portalSessionId: "portal-session-1",
tenantSlug: "acme",
tenantFrozen: false,
portalTitle: "Acme Portal",
viewerFirstName: "Karla",
viewerLastName: "Kunde",
viewerLocale: "de",
origin: "https://portal.hivegrid.de",
createdAt: new Date("2026-07-15T10:00:00.000Z"),
lastSeenAt: new Date("2026-07-15T11:00:00.000Z"),
expiresAt: new Date("2026-07-16T12:00:00.000Z"),
} as const;
const visibleProject = {
id: "project-visible",
projectNumber: "P-1001",
name: "Sichtbares Projekt",
updatedAt: "2026-07-15T10:00:00.000Z",
currentStageOrder: 10,
hasActiveAccess: true,
stages: [{ id: "stage-1", label: "Planung", order: 10, visible: true }],
documents: [],
} as const;
function loadProject(projectId: string): Promise<Response> {
return loader({
request: new Request(`https://portal.hivegrid.de/__portal/acme/projects/${projectId}`, {
headers: { "x-hivegrid-portal-tenant": "acme" },
}),
params: { tenant: "acme", projectId },
context: {},
unstable_pattern: "/__portal?/:tenant/projects/:projectId",
}) as Promise<Response>;
}
describe("customer portal project-detail boundary", () => {
beforeEach(() => {
vi.clearAllMocks();
portalData.requirePortalSessionContext.mockResolvedValue({
identity,
origin: {
origin: "https://portal.hivegrid.de",
hostname: "portal.hivegrid.de",
tenantSlug: "acme",
customHost: false,
},
responseHeaders: new Headers({ "Cache-Control": "no-store", "Set-Cookie": "portal-session=refreshed" }),
});
portalData.loadPortalProjectDataset.mockResolvedValue({ identity, projects: [visibleProject] });
portalInteractions.loadPortalProjectInteractionsVM.mockResolvedValue({ status: "empty" });
});
it("returns byte-identical opaque 404 payloads for inaccessible and missing project ids", async () => {
// The first id represents an existing project omitted by the access-scoped
// dataset; the second does not exist. The route must not reveal which case
// occurred through status, headers, or response data.
const inaccessible = await loadProject("project-outside-access");
const missing = await loadProject("project-does-not-exist");
expect(inaccessible.status).toBe(404);
expect(missing.status).toBe(404);
expect(inaccessible.headers.get("Cache-Control")).toBe("no-store");
expect(inaccessible.headers.get("Set-Cookie")).toBe("portal-session=refreshed");
expect([...inaccessible.headers]).toEqual([...missing.headers]);
expect(await inaccessible.text()).toBe(await missing.text());
expect(portalData.loadPortalProjectDataset).toHaveBeenCalledTimes(2);
});
it("returns the detail only when it is present in the access-scoped dataset", async () => {
const response = await loadProject("project-visible");
const data = await response.json();
expect(response.status).toBe(200);
expect(response.headers.get("Set-Cookie")).toBe("portal-session=refreshed");
expect(data).toMatchObject({
tenantSlug: "acme",
vm: { status: "ready", data: { id: "project-visible", name: "Sichtbares Projekt" } },
});
expect(portalInteractions.loadPortalProjectInteractionsVM).toHaveBeenCalledWith(
expect.objectContaining({ pendingFilename: "translated:customerPortal.upload.pendingFilename" })
);
});
});
@@ -0,0 +1,117 @@
import { buildPortalProjectDetailVM } from "@hivegrid/view-models";
import { useRef, useState } from "react";
import { useFetcher, useLoaderData, useNavigate, useRevalidator, useRouteLoaderData, type LoaderFunctionArgs } from "react-router";
import { CustomerPortalProjectDetailPage } from "~/components/screens/customer-portal/CustomerPortalInterimPages";
import { getTranslations } from "~/locale/i18next.server";
import { loadPortalProjectDataset, portalNotFound, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import { loadPortalProjectInteractionsVM } from "~/services/customer-portal/portal-interactions-data.server";
import type { PortalRootData } from "~/services/customer-portal/portal-root";
import { portalPublicPath } from "~/services/customer-portal/portal-origin.server";
import { portalUploadSelectionSignature, uploadPortalFileBatch, type PortalUploadActionResult } from "~/services/customer-portal/portal-upload-batch.client";
export async function loader({ request, params }: LoaderFunctionArgs) {
if (!params.projectId) throw portalNotFound();
const session = await requirePortalSessionContext(request, params.tenant);
const { t } = await getTranslations(request);
const { identity } = session;
const baseHref = portalPublicPath(session.origin);
const dataset = await loadPortalProjectDataset(identity, undefined, baseHref);
const paths = {
dashboard: baseHref,
projects: portalPublicPath(session.origin, "projects"),
upload: portalPublicPath(session.origin, "upload"),
settings: portalPublicPath(session.origin, "settings"),
logout: portalPublicPath(session.origin, "logout"),
};
const project = dataset.projects.find((candidate) => candidate.id === params.projectId) ?? null;
const interactionsVM = project
? await loadPortalProjectInteractionsVM({
identity,
projectId: project.id,
projectLabel: project.name,
pendingFilename: t("customerPortal.upload.pendingFilename"),
uploadAction: portalPublicPath(session.origin, `projects/${project.id}/upload`),
complaintAction: (formId) => portalPublicPath(session.origin, `projects/${project.id}/complaints/${formId}`),
})
: { status: "empty" as const };
const data = {
vm: buildPortalProjectDetailVM({
frozen: identity.tenantFrozen,
project,
projectsHref: paths.projects,
locale: identity.viewerLocale,
}),
portalName: identity.portalTitle,
viewerLabel: viewerLabel(identity),
brandingLogoHref: portalPublicPath(session.origin, "branding/logo"),
tenantSlug: identity.tenantSlug,
interactionsVM,
paths,
};
return Response.json(data, { status: project ? 200 : 404, headers: session.responseHeaders });
}
function viewerLabel(identity: { viewerFirstName: string; viewerLastName: string; portalTitle: string }): string {
return `${identity.viewerFirstName} ${identity.viewerLastName}`.trim() || identity.portalTitle;
}
export default function CustomerPortalProjectDetailRoute() {
const data = useLoaderData<typeof loader>();
const root = useRouteLoaderData<PortalRootData>("root");
const navigate = useNavigate();
const revalidator = useRevalidator();
const logout = useFetcher();
const [uploadState, setUploadState] = useState<PortalUploadActionResult & { readonly busy: boolean }>({ ok: false, busy: false });
const pendingUpload = useRef<{ signature: string; batchId: string; running: boolean } | null>(null);
const complaint = useFetcher<{ ok: boolean; messageKey?: string; errorKey?: string }>();
return (
<CustomerPortalProjectDetailPage
vm={data.vm}
interactionsVM={data.interactionsVM}
interactionsState={{
uploadBusy: uploadState.busy,
complaintBusy: complaint.state !== "idle",
uploadMessageKey: uploadState.ok ? uploadState.messageKey : null,
uploadErrorKey: !uploadState.busy && !uploadState.ok ? uploadState.errorKey : null,
complaintMessageKey: complaint.data?.ok ? complaint.data.messageKey : null,
complaintErrorKey: complaint.data?.ok === false ? complaint.data.errorKey : null,
}}
portalName={data.portalName}
viewerLabel={data.viewerLabel}
brandingLogoHref={data.brandingLogoHref}
actions={{
onDashboard: () => navigate(data.paths.dashboard),
onProjects: () => navigate(data.paths.projects),
onUpload: () => navigate(data.paths.upload),
onSettings: () => navigate(data.paths.settings),
onBack: () => navigate(data.paths.projects),
onDownloadDocument: (href) => window.location.assign(href),
onUploadFiles: async (action, files) => {
const signature = portalUploadSelectionSignature(files);
if (pendingUpload.current?.running) return;
const batchId = pendingUpload.current?.signature === signature ? pendingUpload.current.batchId : crypto.randomUUID();
pendingUpload.current = { signature, batchId, running: true };
setUploadState({ ok: false, busy: true });
const result = await uploadPortalFileBatch({ action, files, csrfToken: root?.csrf, batchId });
setUploadState({ ...result, busy: false });
pendingUpload.current = result.ok ? null : { signature, batchId, running: false };
if (result.ok) void revalidator.revalidate();
},
onSubmitComplaint: (action, values, gdprAccepted) => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
form.set("idempotencyKey", crypto.randomUUID());
form.set("gdprAccepted", String(gdprAccepted));
form.set("payload", JSON.stringify(values));
void complaint.submit(form, { method: "post", action });
},
onLogout: () => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
void logout.submit(form, { method: "post", action: data.paths.logout });
},
}}
/>
);
}
@@ -0,0 +1,129 @@
// @vitest-environment jsdom
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => {
class PortalUploadError extends Error {
constructor(readonly code: string) {
super(code);
}
}
class RequestBodyLimitError extends Error {
constructor(readonly limitBytes: number) {
super("request body too large");
}
}
return {
PortalUploadError,
RequestBodyLimitError,
requireSession: vi.fn(),
validateCsrf: vi.fn(),
uploadFiles: vi.fn(),
readLimitedFormData: vi.fn(),
};
});
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireSession,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({ validatePortalCsrfToken: mocks.validateCsrf }));
vi.mock("~/utils/http/readLimitedRequestBody.server", () => ({
RequestBodyLimitError: mocks.RequestBodyLimitError,
readLimitedRequestFormData: mocks.readLimitedFormData,
}));
vi.mock("~/services/customer-portal/portal-upload.server", () => ({
PORTAL_UPLOAD_ABSOLUTE_MAX_FILE_BYTES: 100 * 1024 * 1024,
PORTAL_UPLOAD_ABSOLUTE_REQUEST_BYTES: 101 * 1024 * 1024,
PORTAL_UPLOAD_DEFAULT_MAX_FILES: 10,
PortalUploadError: mocks.PortalUploadError,
uploadPortalFiles: mocks.uploadFiles,
}));
import { action } from "./project-upload";
const session = {
identity: { tenantId: "tenant-a", portalUserId: "portal-user-a", tenantFrozen: false },
responseHeaders: new Headers({ "Set-Cookie": "portal=renewed" }),
};
function args(request: Request) {
return { request, params: { tenant: "acme", projectId: "project-a" }, context: {} } as never;
}
function uploadRequest(files: readonly File[]): Request {
const form = new FormData();
form.set("csrf", "csrf-token");
form.set("idempotencyKey", "upload-key-a");
for (const file of files) form.append("files", file);
mocks.readLimitedFormData.mockResolvedValueOnce(form);
const request = new Request("https://portal.example.test/acme/projects/project-a/upload", { method: "POST" });
return request;
}
function testFile(contents: string, name: string, type: string): File {
const file = new File([contents], name, { type });
Object.defineProperty(file, "arrayBuffer", {
value: async () => new TextEncoder().encode(contents).buffer,
});
return file;
}
describe("customer portal project upload route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireSession.mockResolvedValue(session);
mocks.validateCsrf.mockResolvedValue(undefined);
mocks.uploadFiles.mockResolvedValue([{ uploadId: "upload-a", fileId: "file-a" }]);
});
it("forwards every selected file through the portal session after CSRF validation", async () => {
const request = uploadRequest([testFile("photo", "baustelle.jpg", "image/jpeg"), testFile("voice", "memo.mp3", "audio/mpeg")]);
const response = await action(args(request));
expect(response.status).toBe(201);
expect(mocks.validateCsrf).toHaveBeenCalledWith(request, expect.any(FormData));
expect(mocks.readLimitedFormData).toHaveBeenCalledWith(request, 101 * 1024 * 1024);
expect(mocks.uploadFiles).toHaveBeenCalledWith({
identity: session.identity,
projectId: "project-a",
idempotencyKey: "upload-key-a",
files: [
{ name: "baustelle.jpg", mimeType: "image/jpeg", bytes: expect.any(Uint8Array) },
{ name: "memo.mp3", mimeType: "audio/mpeg", bytes: expect.any(Uint8Array) },
],
});
await expect(response.json()).resolves.toMatchObject({ ok: true, messageKey: "customerPortal.upload.success" });
});
it("returns a stable M002 key before the service when more than ten files are posted", async () => {
const files = Array.from({ length: 11 }, (_, index) => testFile(String(index), `file-${index}.jpg`, "image/jpeg"));
const response = await action(args(uploadRequest(files)));
expect(response.status).toBe(413);
await expect(response.json()).resolves.toEqual({ ok: false, errorKey: "customerPortal.upload.errors.tooManyFiles" });
expect(mocks.uploadFiles).not.toHaveBeenCalled();
});
it("rejects a streamed body that exceeds the absolute request limit before parsing files", async () => {
mocks.readLimitedFormData.mockRejectedValueOnce(new mocks.RequestBodyLimitError(101 * 1024 * 1024));
const request = new Request("https://portal.example.test/acme/projects/project-a/upload", {
method: "POST",
headers: { "content-type": "multipart/form-data; boundary=pilot" },
body: "--pilot--",
});
const response = await action(args(request));
expect(response.status).toBe(413);
expect(response.headers.get("set-cookie")).toBe("portal=renewed");
await expect(response.json()).resolves.toEqual({ ok: false, errorKey: "customerPortal.upload.errors.requestTooLarge" });
expect(mocks.validateCsrf).not.toHaveBeenCalled();
expect(mocks.uploadFiles).not.toHaveBeenCalled();
});
it("maps frozen and revoked project access to a non-enumerating 404", async () => {
mocks.uploadFiles.mockRejectedValueOnce(new mocks.PortalUploadError("PORTAL_FROZEN"));
await expect(action(args(uploadRequest([testFile("photo", "photo.jpg", "image/jpeg")])))).rejects.toMatchObject({ status: 404 });
});
});
@@ -0,0 +1,61 @@
import { randomUUID } from "node:crypto";
import type { ActionFunctionArgs } from "react-router";
import { portalNotFound, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import { validatePortalCsrfToken } from "~/services/customer-portal/portal-csrf.server";
import {
PORTAL_UPLOAD_ABSOLUTE_MAX_FILE_BYTES,
PORTAL_UPLOAD_ABSOLUTE_REQUEST_BYTES,
PORTAL_UPLOAD_DEFAULT_MAX_FILES,
PortalUploadError,
uploadPortalFiles,
} from "~/services/customer-portal/portal-upload.server";
import { readLimitedRequestFormData, RequestBodyLimitError } from "~/utils/http/readLimitedRequestBody.server";
export async function action({ request, params }: ActionFunctionArgs): Promise<Response> {
if (request.method !== "POST" || !params.projectId) throw portalNotFound();
const contentLength = Number(request.headers.get("content-length") ?? "0");
if (Number.isFinite(contentLength) && contentLength > PORTAL_UPLOAD_ABSOLUTE_REQUEST_BYTES) {
return failure("customerPortal.upload.errors.requestTooLarge", 413);
}
const session = await requirePortalSessionContext(request, params.tenant);
let form: FormData;
try {
form = await readLimitedRequestFormData(request, PORTAL_UPLOAD_ABSOLUTE_REQUEST_BYTES);
} catch (error) {
if (error instanceof RequestBodyLimitError) {
return failure("customerPortal.upload.errors.requestTooLarge", 413, session.responseHeaders);
}
throw error;
}
await validatePortalCsrfToken(request, form);
const entries = form.getAll("files");
if (entries.length > PORTAL_UPLOAD_DEFAULT_MAX_FILES) return failure("customerPortal.upload.errors.tooManyFiles", 413);
const files = [];
for (const entry of entries) {
if (!(entry instanceof File)) return failure("customerPortal.upload.errors.filesRequired", 400);
if (entry.size > PORTAL_UPLOAD_ABSOLUTE_MAX_FILE_BYTES) return failure("customerPortal.upload.errors.fileTooLarge", 413);
files.push({ name: entry.name, mimeType: entry.type, bytes: new Uint8Array(await entry.arrayBuffer()) });
}
const idempotencyKey = form.get("idempotencyKey")?.toString().trim() || randomUUID();
try {
const uploaded = await uploadPortalFiles({ identity: session.identity, projectId: params.projectId, files, idempotencyKey });
return Response.json({ ok: true, uploaded, messageKey: "customerPortal.upload.success" }, { status: 201, headers: session.responseHeaders });
} catch (error) {
if (error instanceof PortalUploadError) {
if (error.code === "PORTAL_FROZEN" || error.code === "PROJECT_ACCESS_DENIED") throw portalNotFound();
const status = error.code === "FILE_TOO_LARGE" || error.code === "TOO_MANY_FILES" ? 413 : error.code === "STORAGE_FAILED" ? 503 : 422;
return failure(`customerPortal.upload.errors.${error.code}`, status, session.responseHeaders);
}
return failure("customerPortal.upload.errors.unavailable", 503, session.responseHeaders);
}
}
export async function loader(): Promise<never> {
throw portalNotFound();
}
function failure(errorKey: string, status: number, headers?: Headers): Response {
return Response.json({ ok: false, errorKey }, { status, headers });
}
@@ -0,0 +1,68 @@
import { buildPortalProjectListVM } from "@hivegrid/view-models";
import { useFetcher, useLoaderData, useNavigate, useRouteLoaderData, type LoaderFunctionArgs } from "react-router";
import { CustomerPortalProjectsPage } from "~/components/screens/customer-portal/CustomerPortalInterimPages";
import { loadPortalProjectDataset, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import type { PortalRootData } from "~/services/customer-portal/portal-root";
import { portalPublicPath } from "~/services/customer-portal/portal-origin.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const session = await requirePortalSessionContext(request, params.tenant);
const { identity } = session;
const baseHref = portalPublicPath(session.origin);
const dataset = await loadPortalProjectDataset(identity, undefined, baseHref);
const paths = {
dashboard: baseHref,
projects: portalPublicPath(session.origin, "projects"),
upload: portalPublicPath(session.origin, "upload"),
settings: portalPublicPath(session.origin, "settings"),
logout: portalPublicPath(session.origin, "logout"),
};
const data = {
vm: buildPortalProjectListVM({
frozen: identity.tenantFrozen,
projects: dataset.projects,
dashboardHref: baseHref,
buildProjectHref: (projectId) => portalPublicPath(session.origin, `projects/${projectId}`),
locale: identity.viewerLocale,
}),
portalName: identity.portalTitle,
viewerLabel: viewerLabel(identity),
brandingLogoHref: portalPublicPath(session.origin, "branding/logo"),
paths,
};
const responseHeaders = new Headers(session.responseHeaders);
responseHeaders.set("Cache-Control", "private, no-store");
return Response.json(data, { headers: responseHeaders });
}
function viewerLabel(identity: { viewerFirstName: string; viewerLastName: string; portalTitle: string }): string {
return `${identity.viewerFirstName} ${identity.viewerLastName}`.trim() || identity.portalTitle;
}
export default function CustomerPortalProjectsRoute() {
const data = useLoaderData<typeof loader>();
const root = useRouteLoaderData<PortalRootData>("root");
const navigate = useNavigate();
const logout = useFetcher();
return (
<CustomerPortalProjectsPage
vm={data.vm}
portalName={data.portalName}
viewerLabel={data.viewerLabel}
brandingLogoHref={data.brandingLogoHref}
actions={{
onDashboard: () => navigate(data.paths.dashboard),
onProjects: () => navigate(data.paths.projects),
onUpload: () => navigate(data.paths.upload),
onSettings: () => navigate(data.paths.settings),
onOpenProject: (href) => navigate(href),
onLogout: () => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
void logout.submit(form, { method: "post", action: data.paths.logout });
},
}}
/>
);
}
@@ -0,0 +1,164 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
requireSession: vi.fn(),
loadLifecycle: vi.fn(),
updatePreference: vi.fn(),
requestExport: vi.fn(),
requestDeletion: vi.fn(),
cancelDeletion: vi.fn(),
validateCsrf: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireSession,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({ validatePortalCsrfToken: mocks.validateCsrf }));
vi.mock("~/services/customer-portal/portal-lifecycle.server", () => ({
PortalLifecycleError: class PortalLifecycleError extends Error {
constructor(readonly code: string) {
super(code);
}
},
loadPortalLifecycle: mocks.loadLifecycle,
updatePortalNotificationPreference: mocks.updatePreference,
requestPortalGdprExport: mocks.requestExport,
requestPortalAccountDeletion: mocks.requestDeletion,
cancelPortalAccountDeletion: mocks.cancelDeletion,
}));
import { action, loader } from "./settings";
const session = {
identity: {
tenantId: "tenant-a",
portalUserId: "portal-user-a",
tenantFrozen: false,
portalTitle: "Acme Portal",
viewerFirstName: "Karla",
viewerLastName: "Kunde",
},
origin: { origin: "https://portal.example.test", hostname: "portal.example.test", tenantSlug: "acme", customHost: false },
responseHeaders: new Headers({ "Set-Cookie": "portal=renewed" }),
};
function routeArgs(request: Request) {
return { request, params: { tenant: "acme" }, context: {} };
}
function postForm(values: Readonly<Record<string, string>>): Request {
const body = new URLSearchParams();
body.set("csrf", "csrf-token");
for (const [key, value] of Object.entries(values)) body.set(key, value);
return new Request("https://portal.example.test/acme/settings", { method: "POST", body });
}
describe("customer portal lifecycle settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireSession.mockResolvedValue(session);
mocks.validateCsrf.mockResolvedValue(undefined);
mocks.loadLifecycle.mockResolvedValue({
profile: {
email: "karla@example.test",
firstName: "Karla",
lastName: "Kunde",
phone: null,
locale: "de",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
lastLoginAt: null,
lastActivityAt: null,
},
notificationPreferences: [{ eventType: "status_mail", emailEnabled: false, mutedUntil: null }],
exportJobs: [
{
id: "export-a",
status: "ready",
progressPercent: 100,
createdAt: new Date("2026-07-16T08:00:00.000Z"),
resultExpiresAt: new Date("2099-07-17T08:00:00.000Z"),
failureCode: null,
},
],
deletionRequest: null,
});
mocks.updatePreference.mockResolvedValue("preference-a");
mocks.requestExport.mockResolvedValue({ exportId: "export-a" });
mocks.requestDeletion.mockResolvedValue({
deletionRequestId: "deletion-a",
requestedAt: new Date(),
cancellableUntil: new Date(),
});
mocks.cancelDeletion.mockResolvedValue(undefined);
});
it("builds a complete VM with persisted preferences, safe defaults, and a private download path", async () => {
const response = await loader(routeArgs(new Request("https://portal.example.test/acme/settings")));
const data = (await response.json()) as {
vm: { status: string; data: { notificationPreferences: Array<{ eventType: string; emailEnabled: boolean }>; exportJobs: Array<{ downloadHref: string }> } };
paths: { settings: string };
};
expect(response.headers.get("Cache-Control")).toBe("private, no-store");
expect(data.paths.settings).toBe("/acme/settings");
expect(data.vm.status).toBe("ready");
expect(data.vm.data.notificationPreferences).toHaveLength(2);
expect(data.vm.data.notificationPreferences).toContainEqual({
eventType: "status_mail",
emailEnabled: false,
mutedUntil: null,
});
expect(data.vm.data.notificationPreferences).toContainEqual({
eventType: "lifecycle",
emailEnabled: true,
mutedUntil: null,
});
expect(data.vm.data.exportJobs[0]?.downloadHref).toBe("/acme/exports/export-a");
});
it("validates CSRF and forwards deletion confirmation through the portal session", async () => {
const request = postForm({
intent: "request_deletion",
password: "correct horse battery staple",
idempotencyKey: "deletion-key-a",
});
const response = await action(routeArgs(request));
expect(response.status).toBe(202);
await expect(response.json()).resolves.toEqual({
ok: true,
messageKey: "customerPortal.lifecycle.messages.deletionRequested",
});
expect(mocks.validateCsrf).toHaveBeenCalledWith(request, expect.objectContaining({ get: expect.any(Function) }));
expect(mocks.requestDeletion).toHaveBeenCalledWith(session, {
password: "correct horse battery staple",
idempotencyKey: "deletion-key-a",
request,
});
});
it("persists only allow-listed notification event types", async () => {
const request = postForm({ intent: "preference", eventType: "lifecycle", enabled: "false" });
const response = await action(routeArgs(request));
expect(response.status).toBe(200);
expect(mocks.updatePreference).toHaveBeenCalledWith(session, {
eventType: "lifecycle",
emailEnabled: false,
});
const invalid = await action(routeArgs(postForm({ intent: "preference", eventType: "billing", enabled: "true" })));
expect(invalid.status).toBe(400);
const removed = await action(routeArgs(postForm({ intent: "preference", eventType: "document_released", enabled: "true" })));
expect(removed.status).toBe(400);
expect(mocks.updatePreference).toHaveBeenCalledTimes(1);
});
it("returns 404 for all lifecycle mutations on a frozen tenant", async () => {
mocks.requireSession.mockResolvedValueOnce({ ...session, identity: { ...session.identity, tenantFrozen: true } });
await expect(action(routeArgs(postForm({ intent: "request_export" })))).rejects.toMatchObject({ status: 404 });
expect(mocks.validateCsrf).not.toHaveBeenCalled();
expect(mocks.requestExport).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,199 @@
import { randomUUID } from "node:crypto";
import { buildPortalLifecycleVM } from "@hivegrid/view-models";
import { useFetcher, useLoaderData, useNavigate, useRouteLoaderData, type ActionFunctionArgs, type LoaderFunctionArgs } from "react-router";
import { CustomerPortalSettingsPage } from "~/components/screens/customer-portal/CustomerPortalInterimPages";
import { validatePortalCsrfToken } from "~/services/customer-portal/portal-csrf.server";
import { portalNotFound, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import {
cancelPortalAccountDeletion,
loadPortalLifecycle,
PortalLifecycleError,
requestPortalAccountDeletion,
requestPortalGdprExport,
updatePortalNotificationPreference,
type PortalLifecyclePreference,
} from "~/services/customer-portal/portal-lifecycle.server";
import { portalPublicPath } from "~/services/customer-portal/portal-origin.server";
import type { PortalRootData } from "~/services/customer-portal/portal-root";
const NOTIFICATION_EVENT_TYPES = ["status_mail", "lifecycle"] as const satisfies readonly PortalLifecyclePreference["eventType"][];
type LifecycleActionData = {
readonly ok: boolean;
readonly messageKey?: string;
readonly errorKey?: string;
};
export async function loader({ request, params }: LoaderFunctionArgs): Promise<Response> {
const session = await requirePortalSessionContext(request, params.tenant);
const snapshot = await loadPortalLifecycle(session);
const preferences = new Map(snapshot.notificationPreferences.map((preference) => [preference.eventType, preference]));
const vm = buildPortalLifecycleVM({
frozen: session.identity.tenantFrozen,
profile: {
name: `${snapshot.profile.firstName} ${snapshot.profile.lastName}`.trim() || snapshot.profile.email,
email: snapshot.profile.email,
phone: snapshot.profile.phone,
locale: snapshot.profile.locale,
},
notificationPreferences: NOTIFICATION_EVENT_TYPES.map((eventType) => {
const stored = preferences.get(eventType);
return {
eventType,
emailEnabled: stored?.emailEnabled ?? true,
mutedUntil: stored?.mutedUntil?.toISOString() ?? null,
};
}),
exportJobs: snapshot.exportJobs.map((job) => ({
id: job.id,
status: job.status,
progressPercent: job.progressPercent,
requestedAt: job.createdAt.toISOString(),
expiresAt: job.resultExpiresAt?.toISOString() ?? null,
downloadHref: job.status === "ready" ? portalPublicPath(session.origin, `exports/${job.id}`) : null,
})),
deletionRequest: snapshot.deletionRequest
? {
id: snapshot.deletionRequest.id,
status: snapshot.deletionRequest.status,
requestedAt: snapshot.deletionRequest.requestedAt.toISOString(),
cancellableUntil: snapshot.deletionRequest.cancellableUntil.toISOString(),
}
: null,
});
const baseHref = portalPublicPath(session.origin);
const responseHeaders = new Headers(session.responseHeaders);
responseHeaders.set("Cache-Control", "private, no-store");
return Response.json(
{
vm,
portalName: session.identity.portalTitle,
viewerLabel: `${session.identity.viewerFirstName} ${session.identity.viewerLastName}`.trim() || session.identity.portalTitle,
brandingLogoHref: portalPublicPath(session.origin, "branding/logo"),
paths: {
dashboard: baseHref,
projects: portalPublicPath(session.origin, "projects"),
upload: portalPublicPath(session.origin, "upload"),
settings: portalPublicPath(session.origin, "settings"),
logout: portalPublicPath(session.origin, "logout"),
},
},
{ headers: responseHeaders }
);
}
export async function action({ request, params }: ActionFunctionArgs): Promise<Response> {
if (request.method !== "POST") throw portalNotFound();
const session = await requirePortalSessionContext(request, params.tenant);
if (session.identity.tenantFrozen) throw portalNotFound();
const form = await request.formData();
await validatePortalCsrfToken(request, form);
const intent = form.get("intent")?.toString();
try {
if (intent === "preference") {
const eventType = parseNotificationEventType(form.get("eventType"));
const emailEnabled = parseBoolean(form.get("enabled"));
await updatePortalNotificationPreference(session, { eventType, emailEnabled });
return success("customerPortal.lifecycle.messages.preferenceSaved", session.responseHeaders);
}
if (intent === "request_export") {
await requestPortalGdprExport(session, { idempotencyKey: form.get("idempotencyKey")?.toString() || randomUUID(), request });
return success("customerPortal.lifecycle.messages.exportRequested", session.responseHeaders, 202);
}
if (intent === "request_deletion") {
await requestPortalAccountDeletion(session, {
password: form.get("password")?.toString() ?? "",
idempotencyKey: form.get("idempotencyKey")?.toString() || randomUUID(),
request,
});
return success("customerPortal.lifecycle.messages.deletionRequested", session.responseHeaders, 202);
}
if (intent === "cancel_deletion") {
await cancelPortalAccountDeletion(session, {
deletionRequestId: form.get("deletionRequestId")?.toString() ?? "",
request,
});
return success("customerPortal.lifecycle.messages.deletionCancelled", session.responseHeaders);
}
throw new PortalLifecycleError("INVALID_REQUEST");
} catch (error) {
if (error instanceof PortalLifecycleError) return lifecycleFailure(error, session.responseHeaders);
return failure("customerPortal.lifecycle.errors.unavailable", 503, session.responseHeaders);
}
}
export default function CustomerPortalSettingsRoute(): React.JSX.Element {
const data = useLoaderData<typeof loader>();
const root = useRouteLoaderData<PortalRootData>("root");
const navigate = useNavigate();
const lifecycle = useFetcher<LifecycleActionData>();
const logout = useFetcher();
function submitLifecycle(intent: string, values: Readonly<Record<string, string>> = {}): void {
const form = new FormData();
form.set("intent", intent);
if (root?.csrf) form.set("csrf", root.csrf);
for (const [key, value] of Object.entries(values)) form.set(key, value);
void lifecycle.submit(form, { method: "post", action: data.paths.settings });
}
return (
<CustomerPortalSettingsPage
vm={data.vm}
portalName={data.portalName}
viewerLabel={data.viewerLabel}
brandingLogoHref={data.brandingLogoHref}
busy={lifecycle.state !== "idle"}
messageKey={lifecycle.data?.ok ? lifecycle.data.messageKey : null}
errorKey={lifecycle.data?.ok === false ? lifecycle.data.errorKey : null}
actions={{
onDashboard: () => navigate(data.paths.dashboard),
onProjects: () => navigate(data.paths.projects),
onUpload: () => navigate(data.paths.upload),
onSettings: () => navigate(data.paths.settings),
onUpdatePreference: (eventType, enabled) => submitLifecycle("preference", { eventType, enabled: String(enabled) }),
onRequestExport: () => submitLifecycle("request_export", { idempotencyKey: crypto.randomUUID() }),
onDownloadExport: (href) => window.location.assign(href),
onRequestDeletion: (password) => submitLifecycle("request_deletion", { password, idempotencyKey: crypto.randomUUID() }),
onCancelDeletion: (deletionRequestId) => submitLifecycle("cancel_deletion", { deletionRequestId }),
onLogout: () => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
void logout.submit(form, { method: "post", action: data.paths.logout });
},
}}
/>
);
}
function parseNotificationEventType(value: FormDataEntryValue | null): PortalLifecyclePreference["eventType"] {
if (typeof value !== "string" || !NOTIFICATION_EVENT_TYPES.includes(value as PortalLifecyclePreference["eventType"])) {
throw new PortalLifecycleError("INVALID_REQUEST");
}
return value as PortalLifecyclePreference["eventType"];
}
function parseBoolean(value: FormDataEntryValue | null): boolean {
if (value === "true") return true;
if (value === "false") return false;
throw new PortalLifecycleError("INVALID_REQUEST");
}
function success(messageKey: string, headers: Headers, status = 200): Response {
return Response.json({ ok: true, messageKey } satisfies LifecycleActionData, { status, headers });
}
function lifecycleFailure(error: PortalLifecycleError, headers: Headers): Response {
if (error.code === "PASSWORD_REQUIRED") return failure("customerPortal.lifecycle.errors.passwordRequired", 400, headers);
if (error.code === "PASSWORD_INVALID") return failure("customerPortal.lifecycle.errors.passwordInvalid", 422, headers);
if (error.code === "DELETE_ALREADY_PENDING") return failure("customerPortal.lifecycle.errors.deleteAlreadyPending", 409, headers);
if (error.code === "DELETE_NOT_CANCELLABLE") return failure("customerPortal.lifecycle.errors.deleteNotCancellable", 409, headers);
if (error.code === "EXPORT_NOT_AVAILABLE") return failure("customerPortal.lifecycle.errors.unavailable", 404, headers);
return failure("customerPortal.lifecycle.errors.invalidInput", 400, headers);
}
function failure(errorKey: string, status: number, headers: Headers): Response {
return Response.json({ ok: false, errorKey } satisfies LifecycleActionData, { status, headers });
}
@@ -0,0 +1,84 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
requireSession: vi.fn(),
loadDataset: vi.fn(),
loadInteractions: vi.fn(),
portalPath: vi.fn(),
}));
vi.mock("~/components/screens/customer-portal/CustomerPortalInterimPages", () => ({ CustomerPortalUploadPage: () => null }));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireSession,
loadPortalProjectDataset: mocks.loadDataset,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/services/customer-portal/portal-interactions-data.server", () => ({ loadPortalProjectInteractionsVM: mocks.loadInteractions }));
vi.mock("~/services/customer-portal/portal-origin.server", () => ({ portalPublicPath: mocks.portalPath }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => `translated:${key}` })) }));
import { loader } from "./upload";
const origin = { origin: "https://portal.example.test", tenantSlug: "acme", customHost: false };
const session = {
identity: {
tenantId: "tenant-a",
portalUserId: "portal-user-a",
portalTitle: "Acme Kundenportal",
viewerFirstName: "Karla",
viewerLastName: "Kunde",
},
origin,
responseHeaders: new Headers({ "Set-Cookie": "portal=renewed" }),
};
describe("customer portal upload page loader", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireSession.mockResolvedValue(session);
mocks.portalPath.mockImplementation((_origin: unknown, suffix?: string) => `/acme${suffix ? `/${suffix}` : ""}`);
mocks.loadDataset.mockResolvedValue({
projects: [
{ id: "project-a", projectNumber: "P-1001", name: "Heizung" },
{ id: "project-b", projectNumber: "P-1002", name: "Solar" },
],
});
mocks.loadInteractions.mockResolvedValue({ status: "ready", data: { projectId: "project-b" } });
});
it("selects only an accessible project and builds standard/custom-host-safe actions", async () => {
const response = await loader({
request: new Request("https://portal.example.test/acme/upload?projectId=project-b"),
params: { tenant: "acme" },
context: {},
} as never);
const data = (await response.json()) as {
selectedProjectId: string;
viewerLabel: string;
projectOptions: Array<{ id: string; label: string }>;
paths: Record<string, string>;
};
expect(data.selectedProjectId).toBe("project-b");
expect(data.viewerLabel).toBe("Karla Kunde");
expect(data.projectOptions).toEqual([
{ id: "project-a", label: "P-1001 · Heizung" },
{ id: "project-b", label: "P-1002 · Solar" },
]);
expect(data.paths).toEqual({
dashboard: "/acme",
projects: "/acme/projects",
upload: "/acme/upload",
settings: "/acme/settings",
logout: "/acme/logout",
});
expect(mocks.loadInteractions).toHaveBeenCalledWith({
identity: session.identity,
projectId: "project-b",
projectLabel: "Solar",
pendingFilename: "translated:customerPortal.upload.pendingFilename",
uploadAction: "/acme/projects/project-b/upload",
complaintAction: expect.any(Function),
});
});
});
@@ -0,0 +1,107 @@
import { useRef, useState } from "react";
import { useFetcher, useLoaderData, useNavigate, useRevalidator, useRouteLoaderData, type LoaderFunctionArgs } from "react-router";
import { CustomerPortalUploadPage } from "~/components/screens/customer-portal/CustomerPortalInterimPages";
import { getTranslations } from "~/locale/i18next.server";
import { loadPortalProjectDataset, requirePortalSessionContext } from "~/services/customer-portal/portal-data.server";
import { loadPortalProjectInteractionsVM } from "~/services/customer-portal/portal-interactions-data.server";
import { portalPublicPath } from "~/services/customer-portal/portal-origin.server";
import type { PortalRootData } from "~/services/customer-portal/portal-root";
import { portalUploadSelectionSignature, uploadPortalFileBatch, type PortalUploadActionResult } from "~/services/customer-portal/portal-upload-batch.client";
export async function loader({ request, params }: LoaderFunctionArgs): Promise<Response> {
const session = await requirePortalSessionContext(request, params.tenant);
const { t } = await getTranslations(request);
const baseHref = portalPublicPath(session.origin);
const dataset = await loadPortalProjectDataset(session.identity, undefined, baseHref);
const requestedProjectId = new URL(request.url).searchParams.get("projectId");
const selectedProject = dataset.projects.find((project) => project.id === requestedProjectId) ?? dataset.projects[0] ?? null;
const vm = selectedProject
? await loadPortalProjectInteractionsVM({
identity: session.identity,
projectId: selectedProject.id,
projectLabel: selectedProject.name,
pendingFilename: t("customerPortal.upload.pendingFilename"),
uploadAction: portalPublicPath(session.origin, `projects/${selectedProject.id}/upload`),
complaintAction: (formId) => portalPublicPath(session.origin, `projects/${selectedProject.id}/complaints/${formId}`),
})
: { status: "empty" as const };
return Response.json(
{
vm,
portalName: session.identity.portalTitle,
viewerLabel: `${session.identity.viewerFirstName} ${session.identity.viewerLastName}`.trim() || session.identity.portalTitle,
brandingLogoHref: portalPublicPath(session.origin, "branding/logo"),
selectedProjectId: selectedProject?.id ?? null,
projectOptions: dataset.projects.map((project) => ({ id: project.id, label: `${project.projectNumber} · ${project.name}` })),
paths: {
dashboard: baseHref,
projects: portalPublicPath(session.origin, "projects"),
upload: portalPublicPath(session.origin, "upload"),
settings: portalPublicPath(session.origin, "settings"),
logout: portalPublicPath(session.origin, "logout"),
},
},
{ headers: session.responseHeaders }
);
}
export default function CustomerPortalUploadRoute(): React.JSX.Element {
const data = useLoaderData<typeof loader>();
const root = useRouteLoaderData<PortalRootData>("root");
const navigate = useNavigate();
const revalidator = useRevalidator();
const [uploadState, setUploadState] = useState<PortalUploadActionResult & { readonly busy: boolean }>({ ok: false, busy: false });
const pendingUpload = useRef<{ signature: string; batchId: string; running: boolean } | null>(null);
const complaint = useFetcher<{ ok: boolean; messageKey?: string; errorKey?: string }>();
const logout = useFetcher();
return (
<CustomerPortalUploadPage
vm={data.vm}
portalName={data.portalName}
viewerLabel={data.viewerLabel}
brandingLogoHref={data.brandingLogoHref}
projectOptions={data.projectOptions}
selectedProjectId={data.selectedProjectId}
interactionsState={{
uploadBusy: uploadState.busy,
complaintBusy: complaint.state !== "idle",
uploadMessageKey: uploadState.ok ? uploadState.messageKey : null,
uploadErrorKey: !uploadState.busy && !uploadState.ok ? uploadState.errorKey : null,
complaintMessageKey: complaint.data?.ok ? complaint.data.messageKey : null,
complaintErrorKey: complaint.data?.ok === false ? complaint.data.errorKey : null,
}}
actions={{
onDashboard: () => navigate(data.paths.dashboard),
onProjects: () => navigate(data.paths.projects),
onUpload: () => navigate(data.paths.upload),
onSettings: () => navigate(data.paths.settings),
onSelectProject: (projectId) => navigate(`${data.paths.upload}?projectId=${encodeURIComponent(projectId)}`),
onUploadFiles: async (action, files) => {
const signature = portalUploadSelectionSignature(files);
if (pendingUpload.current?.running) return;
const batchId = pendingUpload.current?.signature === signature ? pendingUpload.current.batchId : crypto.randomUUID();
pendingUpload.current = { signature, batchId, running: true };
setUploadState({ ok: false, busy: true });
const result = await uploadPortalFileBatch({ action, files, csrfToken: root?.csrf, batchId });
setUploadState({ ...result, busy: false });
pendingUpload.current = result.ok ? null : { signature, batchId, running: false };
if (result.ok) void revalidator.revalidate();
},
onSubmitComplaint: (action, values, gdprAccepted) => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
form.set("idempotencyKey", crypto.randomUUID());
form.set("gdprAccepted", String(gdprAccepted));
form.set("payload", JSON.stringify(values));
void complaint.submit(form, { method: "post", action });
},
onLogout: () => {
const form = new FormData();
if (root?.csrf) form.set("csrf", root.csrf);
void logout.submit(form, { method: "post", action: data.paths.logout });
},
}}
/>
);
}