472 lines
13 KiB
TypeScript
472 lines
13 KiB
TypeScript
import { z } from "zod";
|
|
import { createTRPCRouter, controllerProcedure } from "../trpc.js";
|
|
|
|
type AuditUser = { id: string; name: string | null; email: string | null } | null | undefined;
|
|
|
|
type AuditEntryShape = {
|
|
id: string;
|
|
entityType: string;
|
|
entityId: string;
|
|
entityName?: string | null;
|
|
action: string;
|
|
userId?: string | null;
|
|
source?: string | null;
|
|
summary?: string | null;
|
|
createdAt: Date;
|
|
user?: AuditUser;
|
|
};
|
|
|
|
type AuditDetailEntryShape = AuditEntryShape & {
|
|
changes?: unknown;
|
|
};
|
|
|
|
function formatAuditListEntry(entry: AuditEntryShape) {
|
|
return {
|
|
id: entry.id,
|
|
entityType: entry.entityType,
|
|
entityId: entry.entityId,
|
|
entityName: entry.entityName ?? null,
|
|
action: entry.action,
|
|
userId: entry.userId ?? null,
|
|
source: entry.source ?? null,
|
|
summary: entry.summary ?? null,
|
|
createdAt: entry.createdAt.toISOString(),
|
|
user: entry.user
|
|
? {
|
|
id: entry.user.id,
|
|
name: entry.user.name,
|
|
email: entry.user.email,
|
|
}
|
|
: null,
|
|
};
|
|
}
|
|
|
|
function formatAuditDetailEntry(entry: AuditDetailEntryShape) {
|
|
return {
|
|
...formatAuditListEntry(entry),
|
|
changes: entry.changes ?? null,
|
|
};
|
|
}
|
|
|
|
type AuditListInput = {
|
|
entityType?: string;
|
|
entityId?: string;
|
|
userId?: string;
|
|
action?: string;
|
|
source?: string;
|
|
startDate?: Date;
|
|
endDate?: Date;
|
|
search?: string;
|
|
limit: number;
|
|
cursor?: string;
|
|
};
|
|
|
|
type AuditTimelineInput = {
|
|
startDate?: Date;
|
|
endDate?: Date;
|
|
limit: number;
|
|
};
|
|
|
|
function toAuditListInput(input: {
|
|
entityType?: string | undefined;
|
|
entityId?: string | undefined;
|
|
userId?: string | undefined;
|
|
action?: string | undefined;
|
|
source?: string | undefined;
|
|
startDate?: Date | undefined;
|
|
endDate?: Date | undefined;
|
|
search?: string | undefined;
|
|
limit: number;
|
|
cursor?: string | undefined;
|
|
}): AuditListInput {
|
|
return {
|
|
limit: input.limit,
|
|
...(input.entityType !== undefined ? { entityType: input.entityType } : {}),
|
|
...(input.entityId !== undefined ? { entityId: input.entityId } : {}),
|
|
...(input.userId !== undefined ? { userId: input.userId } : {}),
|
|
...(input.action !== undefined ? { action: input.action } : {}),
|
|
...(input.source !== undefined ? { source: input.source } : {}),
|
|
...(input.startDate !== undefined ? { startDate: input.startDate } : {}),
|
|
...(input.endDate !== undefined ? { endDate: input.endDate } : {}),
|
|
...(input.search !== undefined ? { search: input.search } : {}),
|
|
...(input.cursor !== undefined ? { cursor: input.cursor } : {}),
|
|
};
|
|
}
|
|
|
|
function toAuditTimelineInput(input: {
|
|
startDate?: Date | undefined;
|
|
endDate?: Date | undefined;
|
|
limit: number;
|
|
}): AuditTimelineInput {
|
|
return {
|
|
limit: input.limit,
|
|
...(input.startDate !== undefined ? { startDate: input.startDate } : {}),
|
|
...(input.endDate !== undefined ? { endDate: input.endDate } : {}),
|
|
};
|
|
}
|
|
|
|
function buildAuditListWhere(input: Omit<AuditListInput, "limit" | "cursor">) {
|
|
const { entityType, entityId, userId, action, source, startDate, endDate, search } = input;
|
|
const where: Record<string, unknown> = {};
|
|
|
|
if (entityType) where.entityType = entityType;
|
|
if (entityId) where.entityId = entityId;
|
|
if (userId) where.userId = userId;
|
|
if (action) where.action = action;
|
|
if (source) where.source = source;
|
|
|
|
if (startDate || endDate) {
|
|
const createdAt: Record<string, Date> = {};
|
|
if (startDate) createdAt.gte = startDate;
|
|
if (endDate) createdAt.lte = endDate;
|
|
where.createdAt = createdAt;
|
|
}
|
|
|
|
if (search) {
|
|
where.OR = [
|
|
{ entityName: { contains: search, mode: "insensitive" } },
|
|
{ summary: { contains: search, mode: "insensitive" } },
|
|
{ entityType: { contains: search, mode: "insensitive" } },
|
|
];
|
|
}
|
|
|
|
if (!startDate && !endDate && !entityId) {
|
|
const thirtyDaysAgo = new Date();
|
|
thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
|
|
where.createdAt = { ...(where.createdAt as Record<string, Date> ?? {}), gte: thirtyDaysAgo };
|
|
}
|
|
|
|
return where;
|
|
}
|
|
|
|
async function listAuditEntries(
|
|
db: { auditLog: { findMany: Function } },
|
|
input: AuditListInput,
|
|
) {
|
|
const items = await db.auditLog.findMany({
|
|
where: buildAuditListWhere(input),
|
|
select: {
|
|
id: true,
|
|
entityType: true,
|
|
entityId: true,
|
|
entityName: true,
|
|
action: true,
|
|
userId: true,
|
|
source: true,
|
|
summary: true,
|
|
createdAt: true,
|
|
user: { select: { id: true, name: true, email: true } },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
take: input.limit + 1,
|
|
...(input.cursor ? { cursor: { id: input.cursor }, skip: 1 } : {}),
|
|
});
|
|
|
|
let nextCursor: string | undefined;
|
|
if (items.length > input.limit) {
|
|
const next = items.pop();
|
|
nextCursor = next?.id;
|
|
}
|
|
|
|
return { items, nextCursor };
|
|
}
|
|
|
|
async function getAuditEntryById(
|
|
db: { auditLog: { findUniqueOrThrow: Function } },
|
|
id: string,
|
|
) {
|
|
return db.auditLog.findUniqueOrThrow({
|
|
where: { id },
|
|
include: { user: { select: { id: true, name: true, email: true } } },
|
|
});
|
|
}
|
|
|
|
async function getAuditEntriesByEntity(
|
|
db: { auditLog: { findMany: Function } },
|
|
input: { entityType: string; entityId: string; limit: number },
|
|
) {
|
|
return db.auditLog.findMany({
|
|
where: {
|
|
entityType: input.entityType,
|
|
entityId: input.entityId,
|
|
},
|
|
include: {
|
|
user: { select: { id: true, name: true, email: true } },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
take: input.limit,
|
|
});
|
|
}
|
|
|
|
async function getAuditTimeline(
|
|
db: { auditLog: { findMany: Function } },
|
|
input: AuditTimelineInput,
|
|
) {
|
|
const where: Record<string, unknown> = {};
|
|
|
|
if (input.startDate || input.endDate) {
|
|
const createdAt: Record<string, Date> = {};
|
|
if (input.startDate) createdAt.gte = input.startDate;
|
|
if (input.endDate) createdAt.lte = input.endDate;
|
|
where.createdAt = createdAt;
|
|
}
|
|
|
|
const entries = await db.auditLog.findMany({
|
|
where,
|
|
include: {
|
|
user: { select: { id: true, name: true, email: true } },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
take: input.limit,
|
|
});
|
|
|
|
const grouped: Record<string, typeof entries> = {};
|
|
for (const entry of entries) {
|
|
const dateKey = entry.createdAt.toISOString().slice(0, 10);
|
|
if (!grouped[dateKey]) grouped[dateKey] = [];
|
|
grouped[dateKey].push(entry);
|
|
}
|
|
|
|
return grouped;
|
|
}
|
|
|
|
// ─── Router ───────────────────────────────────────────────────────────────────
|
|
|
|
export const auditLogRouter = createTRPCRouter({
|
|
/**
|
|
* Paginated, filterable list of audit log entries.
|
|
* Cursor-based pagination using createdAt + id.
|
|
*/
|
|
list: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
entityType: z.string().optional(),
|
|
entityId: z.string().optional(),
|
|
userId: z.string().optional(),
|
|
action: z.string().optional(),
|
|
source: z.string().optional(),
|
|
startDate: z.date().optional(),
|
|
endDate: z.date().optional(),
|
|
search: z.string().optional(),
|
|
limit: z.number().min(1).max(100).default(50),
|
|
cursor: z.string().optional(), // id of the last item
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
return listAuditEntries(ctx.db, toAuditListInput({
|
|
entityType: input.entityType,
|
|
entityId: input.entityId,
|
|
userId: input.userId,
|
|
action: input.action,
|
|
source: input.source,
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
search: input.search,
|
|
limit: input.limit,
|
|
cursor: input.cursor,
|
|
}));
|
|
}),
|
|
|
|
listDetail: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
entityType: z.string().optional(),
|
|
entityId: z.string().optional(),
|
|
userId: z.string().optional(),
|
|
action: z.string().optional(),
|
|
source: z.string().optional(),
|
|
startDate: z.date().optional(),
|
|
endDate: z.date().optional(),
|
|
search: z.string().optional(),
|
|
limit: z.number().min(1).max(100).default(50),
|
|
cursor: z.string().optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const result = await listAuditEntries(ctx.db, toAuditListInput({
|
|
entityType: input.entityType,
|
|
entityId: input.entityId,
|
|
userId: input.userId,
|
|
action: input.action,
|
|
source: input.source,
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
search: input.search,
|
|
limit: input.limit,
|
|
cursor: input.cursor,
|
|
}));
|
|
return {
|
|
items: result.items.map(formatAuditListEntry),
|
|
nextCursor: result.nextCursor ?? null,
|
|
};
|
|
}),
|
|
|
|
/**
|
|
* Get a single audit entry with full changes JSONB (for expand/detail view).
|
|
*/
|
|
getById: controllerProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
return getAuditEntryById(ctx.db, input.id);
|
|
}),
|
|
|
|
getByIdDetail: controllerProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const entry = await getAuditEntryById(ctx.db, input.id);
|
|
return formatAuditDetailEntry(entry);
|
|
}),
|
|
|
|
/**
|
|
* Get all audit entries for a specific entity (e.g. a project or resource).
|
|
*/
|
|
getByEntity: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
entityType: z.string(),
|
|
entityId: z.string(),
|
|
limit: z.number().min(1).max(200).default(50),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
return getAuditEntriesByEntity(ctx.db, input);
|
|
}),
|
|
|
|
getByEntityDetail: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
entityType: z.string(),
|
|
entityId: z.string(),
|
|
limit: z.number().min(1).max(200).default(50),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const entries = await getAuditEntriesByEntity(ctx.db, input);
|
|
return {
|
|
entityType: input.entityType,
|
|
entityId: input.entityId,
|
|
entityName: entries[0]?.entityName ?? null,
|
|
itemCount: entries.length,
|
|
items: entries.map(formatAuditDetailEntry),
|
|
};
|
|
}),
|
|
|
|
/**
|
|
* Timeline view: entries grouped by date (YYYY-MM-DD).
|
|
*/
|
|
getTimeline: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
startDate: z.date().optional(),
|
|
endDate: z.date().optional(),
|
|
limit: z.number().min(1).max(500).default(200),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
return getAuditTimeline(ctx.db, toAuditTimelineInput({
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
limit: input.limit,
|
|
}));
|
|
}),
|
|
|
|
getTimelineDetail: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
startDate: z.date().optional(),
|
|
endDate: z.date().optional(),
|
|
limit: z.number().min(1).max(500).default(200),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const timeline = await getAuditTimeline(ctx.db, toAuditTimelineInput({
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
limit: input.limit,
|
|
}));
|
|
return Object.fromEntries(
|
|
Object.entries(timeline).map(([dateKey, entries]) => [
|
|
dateKey,
|
|
entries.map(formatAuditDetailEntry),
|
|
]),
|
|
);
|
|
}),
|
|
|
|
/**
|
|
* Activity summary: counts by entity type, action, and user for a date range.
|
|
*/
|
|
getActivitySummary: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
startDate: z.date().optional(),
|
|
endDate: z.date().optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const where: Record<string, unknown> = {};
|
|
|
|
if (input.startDate || input.endDate) {
|
|
const createdAt: Record<string, Date> = {};
|
|
if (input.startDate) createdAt.gte = input.startDate;
|
|
if (input.endDate) createdAt.lte = input.endDate;
|
|
where.createdAt = createdAt;
|
|
}
|
|
|
|
// Run aggregation queries in parallel
|
|
const [byEntityTypeRaw, byActionRaw, byUserRaw, total] = await Promise.all([
|
|
ctx.db.auditLog.groupBy({
|
|
by: ["entityType"],
|
|
where,
|
|
_count: { id: true },
|
|
}),
|
|
ctx.db.auditLog.groupBy({
|
|
by: ["action"],
|
|
where,
|
|
_count: { id: true },
|
|
}),
|
|
ctx.db.auditLog.groupBy({
|
|
by: ["userId"],
|
|
where,
|
|
_count: { id: true },
|
|
orderBy: { _count: { id: "desc" } },
|
|
take: 20,
|
|
}),
|
|
ctx.db.auditLog.count({ where }),
|
|
]);
|
|
|
|
// Convert to simple Record<string, number>
|
|
const byEntityType: Record<string, number> = {};
|
|
for (const row of byEntityTypeRaw) {
|
|
byEntityType[row.entityType] = row._count.id;
|
|
}
|
|
|
|
const byAction: Record<string, number> = {};
|
|
for (const row of byActionRaw) {
|
|
byAction[row.action] = row._count.id;
|
|
}
|
|
|
|
// Resolve user names for the top users
|
|
const userIds = byUserRaw
|
|
.map((row) => row.userId)
|
|
.filter((id): id is string => id !== null);
|
|
|
|
const users = userIds.length > 0
|
|
? await ctx.db.user.findMany({
|
|
where: { id: { in: userIds } },
|
|
select: { id: true, name: true, email: true },
|
|
})
|
|
: [];
|
|
|
|
const userMap = new Map(users.map((u) => [u.id, u.name ?? u.email]));
|
|
|
|
const byUser = byUserRaw
|
|
.filter((row) => row.userId !== null)
|
|
.map((row) => ({
|
|
name: userMap.get(row.userId!) ?? "Unknown",
|
|
count: row._count.id,
|
|
}));
|
|
|
|
return { byEntityType, byAction, byUser, total };
|
|
}),
|
|
});
|