Files

167 lines
6.6 KiB
TypeScript

/**
* Phase 10 Task #67 — Admin (system-wide) Compliance-Audit-Export.
*
* Streams a filtered CSV of AuditEvent rows across ALL tenants. Filters:
* date range, regulatoryScope, actorType, outcome. The first CSV line is
* a `# verifyAuditChain` integrity header so the download itself doubles
* as evidence that the chain is intact.
*
* Tenant-scoped variant lives at routes/app.$tenant/settings/audit-export.tsx.
*/
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData } from "react-router";
import { getDbClient } from "@hivegrid/db/client.server";
import { loadAuditVerificationContext } from "@hivegrid/db/audit-chain-checkpoint.server";
import { buildAuditExportVM, toAuditExportResultVM, type AuditExportVM } from "@hivegrid/view-models";
import { AuditExportPage } from "~/components/screens/audit/AuditExportPage";
import ServerError from "~/components/ui/errors/ServerError";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
import { getUserInfo } from "~/utils/session.server";
import { getTranslations } from "~/locale/i18next.server";
import {
AUDIT_EXPORT_MAX_ROWS,
buildAuditExportWhere,
computeAuditIntegritySummary,
hasAuditExportPrefixFilters,
parseAuditExportFilters,
renderAuditExportCsv,
stripAuditExportFilterSentinels,
type AuditExportRow,
} from "./audit-export.helpers.server";
import {
AuditExportPurposeRequiredError,
AuditExportStorageUnavailableError,
parseAuditExportFormat,
runAuditExportToStorage,
} from "~/utils/audit/auditExportStorage.server";
type ActionData =
| { ok: true; url: string; rowCount: number; integrityOk: boolean; expiresInSeconds: number }
| { ok: false; errorKey: string };
// Interim-screen Selects submit a "__all__" sentinel for "no filter" (empty
// string is not a valid ~/ui Select value) — treat it as absent everywhere.
const FILTER_ALL = "__all__";
function filtersFromForm(form: FormData): URL {
const params = new URLSearchParams();
for (const key of ["from", "to", "actorType", "outcome", "tenantId"]) {
const value = form.get(key)?.toString().trim();
if (value && value !== FILTER_ALL) params.set(key, value);
}
for (const value of form.getAll("regulatoryScope")) {
const v = value.toString().trim();
if (v && v !== FILTER_ALL) params.append("regulatoryScope", v);
}
return new URL(`https://audit.local/?${params.toString()}`);
}
export const action = async ({ request }: ActionFunctionArgs): Promise<ActionData> => {
await requireAdminIdentityPermission(request, "admin_identity.audit.export");
const [userInfo, form] = await Promise.all([getUserInfo(request), request.formData()]);
const filters = parseAuditExportFilters(filtersFromForm(form));
try {
const result = await runAuditExportToStorage({
filters,
format: parseAuditExportFormat(form.get("format")?.toString()),
purpose: form.get("purpose")?.toString() ?? "",
actor: { id: userInfo.userId, type: "admin" },
tenantId: filters.tenantId,
});
return { ok: true, url: result.url, rowCount: result.rowCount, integrityOk: result.integrityOk, expiresInSeconds: result.expiresInSeconds };
} catch (error) {
if (error instanceof AuditExportPurposeRequiredError) return { ok: false, errorKey: "auditExport.storage.errorPurpose" };
if (error instanceof AuditExportStorageUnavailableError) return { ok: false, errorKey: "auditExport.storage.errorUnavailable" };
throw error;
}
};
type LoaderData = {
title: string;
vm: AuditExportVM;
};
export const loader = async ({ request }: LoaderFunctionArgs) => {
await requireAdminIdentityPermission(request, "admin_identity.audit.export");
const { t } = await getTranslations(request);
const url = stripAuditExportFilterSentinels(new URL(request.url));
if (url.searchParams.get("export") === "csv") {
return streamAdminAuditExport(url);
}
if (url.searchParams.get("export") === "pdf" || url.searchParams.get("format") === "pdf") {
return streamAdminAuditPdfExport(url, t);
}
const today = new Date();
const fromDate = new Date(today);
fromDate.setDate(fromDate.getDate() - 30);
const data: LoaderData = {
title: `${t("translations:models.log.plural")} | ${process.env.APP_NAME}`,
vm: buildAuditExportVM({
defaultFrom: fromDate.toISOString().slice(0, 10),
defaultTo: today.toISOString().slice(0, 10),
maxRows: AUDIT_EXPORT_MAX_ROWS,
}),
};
return Response.json(data);
};
async function streamAdminAuditExport(url: URL): Promise<Response> {
const filters = parseAuditExportFilters(url);
const db = getDbClient();
const rows = (await db.auditEvent.findMany({
where: buildAuditExportWhere(filters),
orderBy: { createdAt: "asc" },
take: AUDIT_EXPORT_MAX_ROWS,
})) as unknown as AuditExportRow[];
const verification = await loadAuditVerificationContext(db as never, rows, {
allowPartialPrefix: hasAuditExportPrefixFilters(filters),
});
const integrity = computeAuditIntegritySummary(rows, verification);
const csv = renderAuditExportCsv(rows, integrity);
return new Response(csv, {
headers: {
"Content-Type": "text/csv; charset=utf-8",
"Content-Disposition": `attachment; filename="audit-export-admin-${url.searchParams.get("from") ?? "all"}_${url.searchParams.get("to") ?? "all"}.csv"`,
"X-Audit-Chain-Status": integrity.ok ? "ok" : "broken",
},
});
}
async function streamAdminAuditPdfExport(url: URL, t: Awaited<ReturnType<typeof getTranslations>>["t"]): Promise<Response> {
const { buildAuditPdfLabels, renderAuditExportPdfResponse } = await import("~/utils/audit/pdfRender");
const filters = parseAuditExportFilters(url);
const db = getDbClient();
const rows = (await db.auditEvent.findMany({
where: buildAuditExportWhere(filters),
orderBy: { createdAt: "asc" },
take: AUDIT_EXPORT_MAX_ROWS,
})) as unknown as AuditExportRow[];
const verification = await loadAuditVerificationContext(db as never, rows, {
allowPartialPrefix: hasAuditExportPrefixFilters(filters),
});
const integrity = computeAuditIntegritySummary(rows, verification);
return renderAuditExportPdfResponse(
{
tenantId: filters.tenantId,
filters,
integrity,
rows,
labels: buildAuditPdfLabels(t),
},
{ filenamePrefix: "audit-export-admin" }
);
}
export default function AdminAuditExportRoute() {
const { vm } = useLoaderData<LoaderData>();
const actionData = useActionData<unknown>();
return <AuditExportPage vm={vm} result={toAuditExportResultVM(actionData)} />;
}
export function ErrorBoundary() {
return <ServerError />;
}