Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/logs.server.ts
T
2026-07-08 16:15:37 +02:00

238 lines
7.6 KiB
TypeScript

import { getDbClient } from "./client.server.js";
import type { Log, Prisma } from "./prisma-browser.js";
export type AdminAuditLogFilters = {
q?: string | null;
action?: string | null;
url?: string | null;
tenantId?: string | null;
userId?: string | null;
createdAtFrom?: string | Date | null;
createdAtTo?: string | Date | null;
};
export type AdminAuditLogListArgs = AdminAuditLogFilters & {
take?: number | null;
skip?: number | null;
};
export type TenantAuditLogFilters = Omit<AdminAuditLogFilters, "tenantId"> & {
tenantId?: string | null;
};
export type TenantAuditLogListArgs = TenantAuditLogFilters & {
take?: number | null;
skip?: number | null;
};
export type AdminAuditLogRow = Log & {
tenant?: { id: string; name: string; slug?: string | null } | null;
user?: { id: string; email: string; firstName?: string | null; lastName?: string | null } | null;
apiKey?: { id: string; alias: string } | null;
};
export type AdminAuditLogListResult = {
rows: AdminAuditLogRow[];
total: number;
take: number;
skip: number;
};
export type AdminAuditLogClient = {
log: {
findMany(args: {
where: Prisma.LogWhereInput;
include: typeof adminAuditLogInclude;
orderBy: Prisma.LogOrderByWithRelationInput;
take: number;
skip: number;
}): Promise<AdminAuditLogRow[]>;
count(args: { where: Prisma.LogWhereInput }): Promise<number>;
};
};
export const adminAuditLogInclude = {
user: { select: { id: true, email: true, firstName: true, lastName: true } },
tenant: { select: { id: true, name: true, slug: true } },
apiKey: { select: { id: true, alias: true } },
} satisfies Prisma.LogInclude;
const DEFAULT_AUDIT_LOG_TAKE = 50;
const MAX_AUDIT_LOG_TAKE = 500;
const CSV_HEADERS = ["Created At", "Tenant", "Actor", "Actor Type", "Action", "URL", "Details"] as const;
const FORMULA_PREFIX_PATTERN = /^[=+\-@\t\r]/;
const SENSITIVE_LOG_KEY_PATTERN = /authorization|cookie|password|secret|token|api[-_]?key|payload|body|header/i;
export function buildAuditLogWhereFromFilters(filters: AdminAuditLogFilters): Prisma.LogWhereInput {
const where: Prisma.LogWhereInput = {};
const and: Prisma.LogWhereInput[] = [];
const q = normalizeFilter(filters.q);
if (q) {
and.push({
OR: [
{ action: { contains: q, mode: "insensitive" } },
{ url: { contains: q, mode: "insensitive" } },
{ details: { contains: q, mode: "insensitive" } },
{ tenantId: { contains: q, mode: "insensitive" } },
{ userId: { contains: q, mode: "insensitive" } },
],
});
}
const action = normalizeFilter(filters.action);
if (action) where.action = action;
const url = normalizeFilter(filters.url);
if (url) where.url = { contains: url, mode: "insensitive" };
const tenantId = normalizeFilter(filters.tenantId);
if (tenantId) where.tenantId = tenantId;
const userId = normalizeFilter(filters.userId);
if (userId) where.userId = userId;
const createdAt: Prisma.DateTimeFilter<"Log"> = {};
const createdAtFrom = parseValidDate(filters.createdAtFrom);
const createdAtTo = parseValidDate(filters.createdAtTo);
if (createdAtFrom) createdAt.gte = createdAtFrom;
if (createdAtTo) createdAt.lte = createdAtTo;
if (Object.keys(createdAt).length > 0) where.createdAt = createdAt;
if (and.length > 0) where.AND = and;
return where;
}
export async function getAdminAuditLogList(
args: AdminAuditLogListArgs,
client: AdminAuditLogClient = getDbClient() as unknown as AdminAuditLogClient,
): Promise<AdminAuditLogListResult> {
const where = buildAuditLogWhereFromFilters(args);
return getAuditLogListWithWhere(where, args, client);
}
export async function getTenantAuditLogList(
tenantId: string,
args: TenantAuditLogListArgs,
client: AdminAuditLogClient = getDbClient() as unknown as AdminAuditLogClient,
): Promise<AdminAuditLogListResult> {
const where = buildAuditLogWhereFromFilters(args);
where.tenantId = tenantId;
return getAuditLogListWithWhere(where, args, client);
}
export function serializeAdminAuditLogsCsv(rows: readonly AdminAuditLogRow[]): string {
const lines = [CSV_HEADERS.map(escapeCsvCell).join(",")];
for (const row of rows) {
lines.push(
[row.createdAt.toISOString(), formatTenant(row), formatActor(row), getActorType(row), row.action, row.url, redactLogDetails(row.details)]
.map(escapeCsvCell)
.join(","),
);
}
return `${lines.join("\n")}\n`;
}
async function getAuditLogListWithWhere(
where: Prisma.LogWhereInput,
args: { take?: number | null; skip?: number | null },
client: AdminAuditLogClient,
): Promise<AdminAuditLogListResult> {
const take = normalizeTake(args.take);
const skip = normalizeSkip(args.skip);
const queryArgs = {
where,
include: adminAuditLogInclude,
orderBy: { createdAt: "desc" } satisfies Prisma.LogOrderByWithRelationInput,
take,
skip,
};
const [rows, total] = await Promise.all([client.log.findMany(queryArgs), client.log.count({ where })]);
return { rows, total, take, skip };
}
function normalizeFilter(value: string | null | undefined): string | undefined {
const normalized = value?.trim();
return normalized ? normalized : undefined;
}
function parseValidDate(value: string | Date | null | undefined): Date | undefined {
if (!value) return undefined;
const date = value instanceof Date ? value : new Date(value);
return Number.isNaN(date.getTime()) ? undefined : date;
}
function normalizeTake(value: number | null | undefined): number {
if (!Number.isFinite(value) || !value || value < 1) return DEFAULT_AUDIT_LOG_TAKE;
return Math.min(Math.trunc(value), MAX_AUDIT_LOG_TAKE);
}
function normalizeSkip(value: number | null | undefined): number {
if (!Number.isFinite(value) || !value || value < 0) return 0;
return Math.trunc(value);
}
function formatTenant(row: AdminAuditLogRow): string {
if (row.tenant) return row.tenant.name || row.tenant.slug || row.tenant.id;
return row.tenantId ?? "";
}
function formatActor(row: AdminAuditLogRow): string {
if (row.user) {
const name = [row.user.firstName, row.user.lastName].filter(Boolean).join(" ").trim();
return name ? `${name} <${row.user.email}>` : row.user.email;
}
if (row.apiKey) return row.apiKey.alias;
return row.userId ?? row.apiKeyId ?? "System";
}
function getActorType(row: AdminAuditLogRow): string {
if (row.userId || row.user) return "User";
if (row.apiKeyId || row.apiKey) return "API Key";
return "System";
}
function escapeCsvCell(value: unknown): string {
const stringValue = String(value ?? "");
const safeValue = FORMULA_PREFIX_PATTERN.test(stringValue) ? `'${stringValue}` : stringValue;
return `"${safeValue.replaceAll('"', '""')}"`;
}
export function redactLogDetails(details?: string | null): string | null {
if (!details) {
return details ?? null;
}
try {
return JSON.stringify(redactLogValue(JSON.parse(details)));
} catch {
return redactSensitiveText(details);
}
}
function redactLogValue(value: unknown): unknown {
if (Array.isArray(value)) {
return value.map(redactLogValue);
}
if (value && typeof value === "object") {
return Object.fromEntries(
Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, SENSITIVE_LOG_KEY_PATTERN.test(key) ? "[REDACTED]" : redactLogValue(entry)]),
);
}
if (typeof value === "string") {
return redactSensitiveText(value);
}
return value;
}
function redactSensitiveText(value: string): string {
return value
.replace(/(authorization)\s*=\s*Bearer\s+\S+/gi, "$1=Bearer [REDACTED]")
.replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]")
.replace(/(password|secret|token|api[-_]?key)=\S+/gi, "$1=[REDACTED]");
}