Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/chat/src/audit.server.ts
T

897 lines
33 KiB
TypeScript

import { logActivity } from "@hivegrid/activity";
import { publishAuditEventViaOutbox } from "@hivegrid/db/audit-events.server";
import type { OutboxPublisherTransaction } from "@hivegrid/db/outbox";
import type { Prisma } from "@hivegrid/db/prisma-browser";
import type { DbTransactionClient } from "@hivegrid/db/transactions.server";
import { CatalogError, foundationErrors, withTenantScope } from "@hivegrid/foundation";
import { CHAT_EVENT_NAMES, isPersistentChatEvent, validateChatServerEvent, type ChatRealtimeMessage } from "@hivegrid/realtime";
import { toPersistedChatEventType } from "./event-type-mapping.js";
import { chatErrors } from "./errors.js";
import { CHAT_PERMISSIONS } from "./permissions.js";
import { publishChatPersistentRealtimeWakeup } from "./realtime-wakeup.server.js";
import { encodeChatMessageCursor, parseChatMessageCursor, runChatRepositoryTransaction } from "./repository.server.js";
import type { ChatAttachmentRecord, ChatMemberChannelDetail, ChatParticipantProfileRecord, ChatRouteRepositoryContext } from "./types.js";
const ACTIVE_TENANT_USER_STATUS = 2;
const AUDIT_MESSAGE_LIMIT = 100;
const AUDIT_MESSAGE_SELECT = {
id: true,
createdAt: true,
updatedAt: true,
tenantId: true,
chatId: true,
authorUserId: true,
clientMessageId: true,
body: true,
bodyFormat: true,
parentMessageId: true,
mentions: true,
linkPreviews: true,
editedAt: true,
deletedAt: true,
systemEventKind: true,
systemEventMetadata: true,
} as const satisfies Prisma.TeamChatMessageSelect;
type AuditMessageRow = Prisma.TeamChatMessageGetPayload<{ select: typeof AUDIT_MESSAGE_SELECT }>;
export type ChatAuditSessionContext = Readonly<{
sessionId: string;
reason: string;
expiresAtIso: string;
}>;
export type ChatAuditAttachmentVariant = "original" | "preview" | "thumb";
export type ChatAuditAttachmentDownload = Readonly<{
fileId: string;
messageId: string;
displayName: string;
storageKey: string;
}>;
export type ChatAuditChannelSummary = Readonly<{
id: string;
kind: "project" | "group" | "dm";
name: string | null;
description: string | null;
projectId: string | null;
isPrivate: boolean;
archivedAtIso: string | null;
lastMessageAtIso: string | null;
memberCount: number;
participants: readonly ChatParticipantProfileRecord[];
}>;
export type ChatAuditAdministrationRecord = Readonly<{
channel: Readonly<{
id: string;
kind: "project" | "group" | "dm";
archivedAtIso: string | null;
}>;
canAdminister: boolean;
members: readonly Readonly<{
userId: string;
displayName: string;
avatarUrl: string | null;
roleInChat: "admin" | "member";
}>[];
}>;
export type ChatAuditAdminMutationResult = Readonly<{
chatId: string;
changed: boolean;
}>;
export async function listChatAuditChannels(
input: ChatRouteRepositoryContext & {
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}
): Promise<readonly ChatAuditChannelSummary[]> {
const requestId = normalizeIdentifier(input.requestId, "requestId");
const auditSession = normalizeAuditSession(input.auditSession);
return runChatRepositoryTransaction(input, CHAT_PERMISSIONS.readAllChannels, async (tx) => {
const channels = await tx.teamChat.findMany({
where: withTenantScope(input.tenantId, {}),
orderBy: [{ lastMessageAt: "desc" }, { createdAt: "desc" }, { id: "desc" }],
select: {
id: true,
kind: true,
name: true,
description: true,
projektId: true,
isPrivate: true,
archivedAt: true,
lastMessageAt: true,
_count: { select: { members: { where: withTenantScope(input.tenantId, { leftAt: null }) } } },
},
});
const participants = await listParticipantProfiles(
tx,
input.tenantId,
channels.map((channel) => channel.id)
);
const profilesByChat = groupParticipantProfiles(participants);
await publishAuditEventViaOutbox(tx as unknown as OutboxPublisherTransaction, {
tenantId: input.tenantId,
actorId: input.userId,
actorType: "user",
action: "chat.audit.channel_listed",
targetType: "Tenant",
targetId: input.tenantId,
requestId,
sourceModule: "chat",
outcome: "success",
dataSensitivity: "confidential",
regulatoryScope: ["gdpr"],
metadata: {
auditSessionId: auditSession.sessionId,
reason: auditSession.reason,
expiresAtIso: auditSession.expiresAtIso,
readOnly: true,
channelCount: channels.length,
},
summaryText: "Die tenantweite Chat-Übersicht wurde im schreibgeschützten Admin-Auditmodus gelesen.",
});
return channels.map((channel) => ({
id: channel.id,
kind: channel.kind,
name: normalizeOptionalText(channel.name),
description: normalizeOptionalText(channel.description),
projectId: channel.projektId,
isPrivate: channel.isPrivate,
archivedAtIso: channel.archivedAt?.toISOString() ?? null,
lastMessageAtIso: channel.lastMessageAt?.toISOString() ?? null,
memberCount: channel._count.members,
participants: profilesByChat.get(channel.id) ?? [],
}));
});
}
export async function getChatAuditChannelDetail(
input: ChatRouteRepositoryContext & {
readonly chatId: string;
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
readonly beforeMessageCursor?: string;
}
): Promise<ChatMemberChannelDetail> {
const chatId = normalizeIdentifier(input.chatId, "chatId");
const requestId = normalizeIdentifier(input.requestId, "requestId");
const auditSession = normalizeAuditSession(input.auditSession);
const beforeMessageCursor = normalizeAuditMessageCursor(input.beforeMessageCursor, chatId);
return runChatRepositoryTransaction(input, CHAT_PERMISSIONS.readAllChannels, async (tx) => {
const channel = await tx.teamChat.findFirst({
where: withTenantScope(input.tenantId, { id: chatId }),
select: {
id: true,
kind: true,
name: true,
description: true,
projektId: true,
isPrivate: true,
archivedAt: true,
lastMessageAt: true,
eventStreamId: true,
_count: { select: { members: { where: withTenantScope(input.tenantId, { leftAt: null }) } } },
},
});
if (!channel) throw new CatalogError(foundationErrors.notFound, { chat: "not-visible" });
const [participants, latestEvent, messageRows] = await Promise.all([
listParticipantProfiles(tx, input.tenantId, [chatId]),
tx.teamChatEvent.findFirst({
where: withTenantScope(input.tenantId, { chatId }),
orderBy: { sequence: "desc" },
select: { sequence: true },
}),
tx.teamChatMessage.findMany({
where: withTenantScope(input.tenantId, {
chatId,
parentMessageId: null,
...(beforeMessageCursor
? {
OR: [{ createdAt: { lt: beforeMessageCursor.createdAt } }, { createdAt: beforeMessageCursor.createdAt, id: { lt: beforeMessageCursor.id } }],
}
: {}),
}),
orderBy: [{ createdAt: "desc" }, { id: "desc" }],
take: AUDIT_MESSAGE_LIMIT + 1,
select: AUDIT_MESSAGE_SELECT,
}),
]);
const hasOlderMessages = messageRows.length > AUDIT_MESSAGE_LIMIT;
const visibleMessages = messageRows.slice(0, AUDIT_MESSAGE_LIMIT).reverse();
const attachments = await listAuditAttachments(
tx,
input.tenantId,
visibleMessages.map((message) => message.id)
);
const attachmentIdsByMessageId = groupAttachmentIds(attachments);
await publishAuditEventViaOutbox(tx as unknown as OutboxPublisherTransaction, {
tenantId: input.tenantId,
actorId: input.userId,
actorType: "user",
action: "chat.audit.channel_opened",
targetType: "TeamChat",
targetId: channel.id,
requestId,
sourceModule: "chat",
outcome: "success",
dataSensitivity: channel.kind === "dm" ? "confidential" : "internal",
regulatoryScope: ["gdpr"],
metadata: {
auditSessionId: auditSession.sessionId,
reason: auditSession.reason,
channelKind: channel.kind,
expiresAtIso: auditSession.expiresAtIso,
readOnly: true,
pageCursor: input.beforeMessageCursor ?? null,
},
summaryText: "Ein Chat-Kanal wurde im schreibgeschützten Admin-Auditmodus geöffnet.",
});
return {
channel: {
id: channel.id,
kind: channel.kind,
name: normalizeOptionalText(channel.name),
description: normalizeOptionalText(channel.description),
projektId: channel.projektId,
isPrivate: channel.isPrivate,
archivedAtIso: channel.archivedAt?.toISOString() ?? null,
lastMessageAtIso: channel.lastMessageAt?.toISOString() ?? null,
eventStreamId: channel.eventStreamId,
eventCursor: latestEvent ? `${channel.eventStreamId}:${latestEvent.sequence.toString()}` : "0",
member: {
roleInChat: "member",
notificationPreference: "muted",
lastReadMessageId: null,
lastReadAtIso: null,
isPinned: false,
canWrite: false,
},
memberCount: channel._count.members,
participants,
unreadCount: 0,
hasUnreadMention: false,
lastMessage: visibleMessages.at(-1)
? mapMessage(visibleMessages.at(-1)!, channel.eventStreamId, attachmentIdsByMessageId.get(visibleMessages.at(-1)!.id) ?? [])
: null,
},
messages: visibleMessages.map((message) => mapMessage(message, channel.eventStreamId, attachmentIdsByMessageId.get(message.id) ?? [])),
readReceipts: [],
messageFeatures: [],
attachments,
hasOlderMessages,
olderMessageCursor: hasOlderMessages && visibleMessages[0] ? encodeChatMessageCursor(chatId, visibleMessages[0]) : null,
eventCursor: latestEvent ? `${channel.eventStreamId}:${latestEvent.sequence.toString()}` : "0",
};
});
}
/**
* Resolve one attachment inside the reason-bound audit transaction. Generic
* Files visibility intentionally cannot use chat.read_all_channels, otherwise
* an administrator could bypass the audit session and its immutable read log.
*/
export async function getChatAuditAttachmentDownload(
input: ChatRouteRepositoryContext & {
readonly chatId: string;
readonly fileId: string;
readonly variant: ChatAuditAttachmentVariant;
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}
): Promise<ChatAuditAttachmentDownload> {
const chatId = normalizeIdentifier(input.chatId, "chatId");
const fileId = normalizeIdentifier(input.fileId, "fileId");
const requestId = normalizeIdentifier(input.requestId, "requestId");
const auditSession = normalizeAuditSession(input.auditSession);
const variant = normalizeAuditAttachmentVariant(input.variant);
return runChatRepositoryTransaction(input, CHAT_PERMISSIONS.readAllChannels, async (tx) => {
const links = await tx.fileEntityLink.findMany({
where: withTenantScope(input.tenantId, { fileId, entityType: "chat_message" as const }),
select: { entityId: true, fileId: true },
});
if (links.length === 0) throw new CatalogError(foundationErrors.notFound, { attachment: "not-visible" });
const linkedMessages = await tx.teamChatMessage.findMany({
where: withTenantScope(input.tenantId, {
id: { in: links.map((link) => link.entityId) },
chatId,
}),
select: { id: true },
take: 1,
});
const message = linkedMessages[0];
if (!message) throw new CatalogError(foundationErrors.notFound, { attachment: "not-visible" });
const files = await tx.file.findMany({
where: withTenantScope(input.tenantId, { id: fileId, archivedAt: null, scanStatus: "clean" as const }),
select: {
id: true,
displayName: true,
storageKey: true,
previewStorageKey: true,
thumbnailStorageKey: true,
},
take: 1,
});
const file = files[0];
if (!file) throw new CatalogError(foundationErrors.notFound, { attachment: "not-deliverable" });
const storageKey = variant === "preview" ? file.previewStorageKey : variant === "thumb" ? file.thumbnailStorageKey : file.storageKey;
if (!storageKey) throw new CatalogError(foundationErrors.notFound, { attachment: "variant-not-deliverable" });
await publishAuditEventViaOutbox(tx as unknown as OutboxPublisherTransaction, {
tenantId: input.tenantId,
actorId: input.userId,
actorType: "user",
action: "chat.audit.attachment_opened",
targetType: "File",
targetId: file.id,
requestId,
sourceModule: "chat",
outcome: "success",
dataSensitivity: "confidential",
regulatoryScope: ["gdpr"],
metadata: {
auditSessionId: auditSession.sessionId,
reason: auditSession.reason,
expiresAtIso: auditSession.expiresAtIso,
chatId,
messageId: message.id,
variant,
readOnly: true,
},
summaryText: "Ein Chat-Anhang wurde im schreibgeschützten Admin-Auditmodus geöffnet.",
});
return {
fileId: file.id,
messageId: message.id,
displayName: file.displayName,
storageKey,
};
});
}
export async function getChatAuditAdministration(input: ChatRouteRepositoryContext & { readonly chatId: string }): Promise<ChatAuditAdministrationRecord> {
const chatId = normalizeIdentifier(input.chatId, "chatId");
return runChatRepositoryTransaction(input, CHAT_PERMISSIONS.readAllChannels, async (tx, currentPermissions) => {
const channel = await tx.teamChat.findFirst({
where: withTenantScope(input.tenantId, { id: chatId }),
select: {
id: true,
kind: true,
archivedAt: true,
members: {
where: withTenantScope(input.tenantId, { leftAt: null }),
orderBy: [{ roleInChat: "asc" }, { userId: "asc" }],
select: { userId: true, roleInChat: true },
},
},
});
if (!channel) throw new CatalogError(foundationErrors.notFound, { chat: "not-visible" });
const participants = await listParticipantProfiles(tx, input.tenantId, [chatId]);
const profiles = new Map(participants.map((participant) => [participant.userId, participant]));
return {
channel: {
id: channel.id,
kind: channel.kind,
archivedAtIso: channel.archivedAt?.toISOString() ?? null,
},
canAdminister: currentPermissions.includes(CHAT_PERMISSIONS.admin),
members: channel.members.flatMap((member) => {
const profile = profiles.get(member.userId);
return profile ? [{ userId: member.userId, displayName: profile.displayName, avatarUrl: profile.avatarUrl, roleInChat: member.roleInChat }] : [];
}),
};
});
}
export async function forceSetChatAuditMemberRole(
input: ChatRouteRepositoryContext & {
readonly chatId: string;
readonly memberUserId: string;
readonly roleInChat: "admin" | "member";
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}
): Promise<ChatAuditAdminMutationResult> {
const normalized = {
...normalizeAuditAdminMutation(input),
memberUserId: normalizeIdentifier(input.memberUserId, "memberUserId"),
};
const roleInChat = normalizeMemberRole(input.roleInChat);
return runChatAuditAdminTransaction(input, async (tx) => {
const channel = await requireAuditChannel(tx, input.tenantId, normalized.chatId);
const member = await tx.teamChatMember.findFirst({
where: withTenantScope(input.tenantId, {
chatId: channel.id,
userId: normalized.memberUserId,
leftAt: null,
}),
select: { id: true, roleInChat: true, joinedAt: true, manualRoleInChat: true, isManualMember: true },
});
if (!member) throw new CatalogError(foundationErrors.notFound, { member: "not-visible" });
const changed = member.roleInChat !== roleInChat || !member.isManualMember || member.manualRoleInChat !== roleInChat;
if (changed) {
const updated = await tx.teamChatMember.updateMany({
where: withTenantScope(input.tenantId, { id: member.id, chatId: channel.id, leftAt: null }),
data: {
roleInChat,
isManualMember: true,
manualRoleInChat: roleInChat,
writeRevokedAt: null,
},
});
if (updated.count !== 1) throw new CatalogError(chatErrors.integrityFailure);
await publishAuditRealtimeEvent(tx, {
tenantId: input.tenantId,
chatId: channel.id,
eventStreamId: channel.eventStreamId,
actorUserId: input.userId,
requestId: normalized.requestId,
event: CHAT_EVENT_NAMES.memberAdded,
data: { userId: normalized.memberUserId, roleInChat, joinedAt: member.joinedAt.toISOString() },
});
}
await publishAuditAdminMutation(tx, input, normalized, channel, {
action: "chat.audit.member_role_forced",
targetType: "TeamChatMember",
targetId: member.id,
metadata: { memberUserId: normalized.memberUserId, previousRoleInChat: member.roleInChat, roleInChat, changed },
summaryText: "Eine Chat-Mitgliedsrolle wurde im begründeten Admin-Auditmodus erzwungen.",
});
return { chatId: channel.id, changed };
});
}
export async function forceRemoveChatAuditMember(
input: ChatRouteRepositoryContext & {
readonly chatId: string;
readonly memberUserId: string;
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}
): Promise<ChatAuditAdminMutationResult> {
const normalized = {
...normalizeAuditAdminMutation(input),
memberUserId: normalizeIdentifier(input.memberUserId, "memberUserId"),
};
return runChatAuditAdminTransaction(input, async (tx) => {
const channel = await requireAuditChannel(tx, input.tenantId, normalized.chatId);
const member = await tx.teamChatMember.findFirst({
where: withTenantScope(input.tenantId, {
chatId: channel.id,
userId: normalized.memberUserId,
leftAt: null,
}),
select: { id: true, roleInChat: true },
});
if (!member) throw new CatalogError(foundationErrors.notFound, { member: "not-visible" });
const leftAt = new Date();
const updated = await tx.teamChatMember.updateMany({
where: withTenantScope(input.tenantId, { id: member.id, chatId: channel.id, leftAt: null }),
data: {
roleInChat: "member",
isManualMember: false,
manualRoleInChat: null,
isProjectManaged: false,
projectRoleInChat: null,
isGroupManaged: false,
writeRevokedAt: leftAt,
leftAt,
},
});
if (updated.count !== 1) throw new CatalogError(chatErrors.integrityFailure);
await publishAuditRealtimeEvent(tx, {
tenantId: input.tenantId,
chatId: channel.id,
eventStreamId: channel.eventStreamId,
actorUserId: input.userId,
requestId: normalized.requestId,
event: CHAT_EVENT_NAMES.memberRemoved,
data: { userId: normalized.memberUserId, leftAt: leftAt.toISOString() },
});
await publishAuditAdminMutation(tx, input, normalized, channel, {
action: "chat.audit.member_removed",
targetType: "TeamChatMember",
targetId: member.id,
metadata: { memberUserId: normalized.memberUserId, previousRoleInChat: member.roleInChat, leftAtIso: leftAt.toISOString() },
summaryText: "Ein Chat-Mitglied wurde im begründeten Admin-Auditmodus entfernt.",
});
return { chatId: channel.id, changed: true };
});
}
export async function forceArchiveChatAuditChannel(
input: ChatRouteRepositoryContext & {
readonly chatId: string;
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}
): Promise<ChatAuditAdminMutationResult> {
const normalized = normalizeAuditAdminMutation(input);
return runChatAuditAdminTransaction(input, async (tx) => {
const channel = await requireAuditChannel(tx, input.tenantId, normalized.chatId);
const changed = channel.archivedAt === null;
if (changed) {
const archivedAt = new Date();
const updated = await tx.teamChat.updateMany({
where: withTenantScope(input.tenantId, { id: channel.id, archivedAt: null }),
data: { archivedAt, archivedReason: "manual" },
});
if (updated.count !== 1) throw new CatalogError(chatErrors.integrityFailure);
await publishAuditRealtimeEvent(tx, {
tenantId: input.tenantId,
chatId: channel.id,
eventStreamId: channel.eventStreamId,
actorUserId: input.userId,
requestId: normalized.requestId,
event: CHAT_EVENT_NAMES.channelArchived,
data: { archivedAt: archivedAt.toISOString(), reason: "manual" },
});
}
await publishAuditAdminMutation(tx, input, normalized, channel, {
action: "chat.audit.channel_archived",
targetType: "TeamChat",
targetId: channel.id,
metadata: { previousArchivedAtIso: channel.archivedAt?.toISOString() ?? null, changed },
summaryText: "Ein Chat-Kanal wurde im begründeten Admin-Auditmodus archiviert.",
});
return { chatId: channel.id, changed };
});
}
type AuditChannelMutationRow = Readonly<{
id: string;
kind: "project" | "group" | "dm";
eventStreamId: string;
archivedAt: Date | null;
}>;
type NormalizedAuditAdminMutation = Readonly<{
chatId: string;
requestId: string;
auditSession: ChatAuditSessionContext;
}>;
type ChatAuditActivityAction =
| "chat.audit.member_role_forced"
| "chat.audit.member_removed"
| "chat.audit.channel_archived";
function chatAuditActivitySummaryKey(action: ChatAuditActivityAction): string {
const summaryKeys: Readonly<Record<ChatAuditActivityAction, string>> = {
"chat.audit.member_role_forced": "activity.runtime.chat.auditMemberRoleChanged",
"chat.audit.member_removed": "activity.runtime.chat.auditMemberRemoved",
"chat.audit.channel_archived": "activity.runtime.chat.auditChannelArchived",
};
return summaryKeys[action];
}
function runChatAuditAdminTransaction<TResult>(input: ChatRouteRepositoryContext, operation: (tx: DbTransactionClient) => Promise<TResult>): Promise<TResult> {
return runChatRepositoryTransaction(input, CHAT_PERMISSIONS.admin, async (tx, currentPermissions) => {
if (!currentPermissions.includes(CHAT_PERMISSIONS.readAllChannels)) {
throw new CatalogError(foundationErrors.notFound);
}
return operation(tx);
});
}
async function requireAuditChannel(tx: DbTransactionClient, tenantId: string, chatId: string): Promise<AuditChannelMutationRow> {
const channel = await tx.teamChat.findFirst({
where: withTenantScope(tenantId, { id: chatId }),
select: { id: true, kind: true, eventStreamId: true, archivedAt: true },
});
if (!channel) throw new CatalogError(foundationErrors.notFound, { chat: "not-visible" });
return channel;
}
function normalizeAuditAdminMutation(input: {
readonly chatId: string;
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}): NormalizedAuditAdminMutation {
return {
chatId: normalizeIdentifier(input.chatId, "chatId"),
requestId: normalizeIdentifier(input.requestId, "requestId"),
auditSession: normalizeAuditSession(input.auditSession),
};
}
function normalizeMemberRole(value: string): "admin" | "member" {
if (value === "admin" || value === "member") return value;
throw new Error("roleInChat is invalid");
}
async function publishAuditAdminMutation(
tx: DbTransactionClient,
input: Pick<ChatRouteRepositoryContext, "tenantId" | "userId">,
normalized: NormalizedAuditAdminMutation,
channel: AuditChannelMutationRow,
event: Readonly<{
action: ChatAuditActivityAction;
targetType: string;
targetId: string;
metadata: Record<string, Prisma.InputJsonValue | null>;
summaryText: string;
}>
): Promise<void> {
await publishAuditEventViaOutbox(tx as unknown as OutboxPublisherTransaction, {
tenantId: input.tenantId,
actorId: input.userId,
actorType: "user",
action: event.action,
targetType: event.targetType,
targetId: event.targetId,
requestId: normalized.requestId,
sourceModule: "chat",
outcome: "success",
dataSensitivity: channel.kind === "dm" ? "confidential" : "internal",
regulatoryScope: ["gdpr"],
metadata: {
auditSessionId: normalized.auditSession.sessionId,
reason: normalized.auditSession.reason,
expiresAtIso: normalized.auditSession.expiresAtIso,
channelId: channel.id,
channelKind: channel.kind,
...event.metadata,
} as Prisma.InputJsonObject,
summaryText: event.summaryText,
});
await logActivity(
{
tenantId: input.tenantId,
actorUserId: input.userId,
actorKind: "user",
activityType: "audit_event",
subjectType: "tenant",
subjectId: input.tenantId,
summaryText: chatAuditActivitySummaryKey(event.action),
metadata: {
sourceModule: "chat",
chatAction: event.action,
channelId: channel.id,
targetType: event.targetType,
targetId: event.targetId,
},
},
{ client: tx }
);
}
type ChatAuditRealtimeMutation =
| Readonly<{
event: typeof CHAT_EVENT_NAMES.memberAdded;
data: { userId: string; roleInChat: "admin" | "member"; joinedAt: string };
}>
| Readonly<{
event: typeof CHAT_EVENT_NAMES.memberRemoved;
data: { userId: string; leftAt: string };
}>
| Readonly<{
event: typeof CHAT_EVENT_NAMES.channelArchived;
data: { archivedAt: string; reason: "manual" };
}>;
async function publishAuditRealtimeEvent(
tx: DbTransactionClient,
input: Readonly<{
tenantId: string;
chatId: string;
eventStreamId: string;
actorUserId: string;
requestId: string;
}> &
ChatAuditRealtimeMutation
): Promise<void> {
const persisted = await tx.teamChatEvent.create({
data: withTenantScope(input.tenantId, {
chatId: input.chatId,
type: toPersistedChatEventType(input.event),
actorUserId: input.actorUserId,
entityId: input.event === CHAT_EVENT_NAMES.channelArchived ? input.chatId : input.data.userId,
requestId: input.requestId,
data: input.data as Prisma.InputJsonObject,
}),
select: { sequence: true, occurredAt: true },
});
const event = validateChatServerEvent({
event: input.event,
cursor: `${input.eventStreamId}:${persisted.sequence.toString()}`,
requestId: input.requestId,
tenantId: input.tenantId,
chatId: input.chatId,
occurredAt: persisted.occurredAt.toISOString(),
data: input.data,
});
if (!isPersistentChatEvent(event)) throw new CatalogError(chatErrors.integrityFailure);
await publishChatPersistentRealtimeWakeup(tx as unknown as OutboxPublisherTransaction, { event });
}
async function listAuditAttachments(tx: DbTransactionClient, tenantId: string, messageIds: readonly string[]): Promise<ChatAttachmentRecord[]> {
if (messageIds.length === 0) return [];
const links = await tx.fileEntityLink.findMany({
where: withTenantScope(tenantId, { entityType: "chat_message" as const, entityId: { in: [...messageIds] } }),
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
select: { entityId: true, fileId: true, linkRole: true },
});
const files = await tx.file.findMany({
where: withTenantScope(tenantId, { id: { in: links.map((link) => link.fileId) }, archivedAt: null }),
select: { id: true, displayName: true, mimeType: true, sizeBytes: true, previewStatus: true, scanStatus: true },
});
const byId = new Map(files.map((file) => [file.id, file]));
return links.flatMap((link) => {
const file = byId.get(link.fileId);
return file
? [
{
messageId: link.entityId,
fileId: file.id,
displayName: file.displayName,
mimeType: file.mimeType,
sizeBytes: file.sizeBytes,
linkRole: link.linkRole,
previewStatus: file.previewStatus,
scanStatus: file.scanStatus,
},
]
: [];
});
}
function groupAttachmentIds(rows: readonly ChatAttachmentRecord[]): Map<string, string[]> {
const grouped = new Map<string, string[]>();
for (const row of rows) grouped.set(row.messageId, [...(grouped.get(row.messageId) ?? []), row.fileId]);
return grouped;
}
export async function recordChatAuditSessionStarted(
input: ChatRouteRepositoryContext & {
readonly requestId: string;
readonly auditSession: ChatAuditSessionContext;
}
): Promise<void> {
const requestId = normalizeIdentifier(input.requestId, "requestId");
const auditSession = normalizeAuditSession(input.auditSession);
await runChatRepositoryTransaction(input, CHAT_PERMISSIONS.readAllChannels, async (tx) => {
await publishAuditEventViaOutbox(tx as unknown as OutboxPublisherTransaction, {
tenantId: input.tenantId,
actorId: input.userId,
actorType: "user",
action: "chat.audit.session_started",
targetType: "Tenant",
targetId: input.tenantId,
requestId,
sourceModule: "chat",
outcome: "success",
dataSensitivity: "confidential",
regulatoryScope: ["gdpr"],
metadata: {
auditSessionId: auditSession.sessionId,
reason: auditSession.reason,
expiresAtIso: auditSession.expiresAtIso,
readOnly: true,
},
summaryText: "Eine zeitlich begrenzte Chat-Admin-Auditsitzung wurde gestartet.",
});
});
}
type ParticipantProjection = ChatParticipantProfileRecord & { readonly chatId: string };
async function listParticipantProfiles(tx: DbTransactionClient, tenantId: string, chatIds: readonly string[]): Promise<ParticipantProjection[]> {
if (chatIds.length === 0) return [];
return tx.$queryRaw<ParticipantProjection[]>`
SELECT participant."chatId" AS "chatId",
participant."userId" AS "userId",
COALESCE(
NULLIF(TRIM(CONCAT_WS(' ', participant_user."firstName", participant_user."lastName")), ''),
participant_user."email"
) AS "displayName",
participant_user."avatar" AS "avatarUrl"
FROM "TeamChatMember" AS participant
INNER JOIN "TenantUser" AS participant_tenant_user
ON participant_tenant_user."tenantId" = participant."tenantId"
AND participant_tenant_user."userId" = participant."userId"
AND participant_tenant_user."status" = ${ACTIVE_TENANT_USER_STATUS}
INNER JOIN "User" AS participant_user
ON participant_user."id" = participant."userId"
AND participant_user."active" = TRUE
AND participant_user."pendingDeletion" = FALSE
AND participant_user."pseudonymized" = FALSE
WHERE participant."tenantId" = ${tenantId}
AND participant."chatId" = ANY(${chatIds}::text[])
AND participant."leftAt" IS NULL
ORDER BY participant."chatId" ASC, "displayName" ASC, participant."userId" ASC
`;
}
function groupParticipantProfiles(rows: readonly ParticipantProjection[]): Map<string, ChatParticipantProfileRecord[]> {
const result = new Map<string, ChatParticipantProfileRecord[]>();
for (const row of rows) {
const current = result.get(row.chatId) ?? [];
current.push({ userId: row.userId, displayName: row.displayName, avatarUrl: row.avatarUrl });
result.set(row.chatId, current);
}
return result;
}
function mapMessage(row: AuditMessageRow, eventStreamId: string, attachmentIds: readonly string[]): ChatRealtimeMessage {
const event = validateChatServerEvent({
event: CHAT_EVENT_NAMES.messageCreated,
cursor: `${eventStreamId}:1`,
requestId: `audit-message-${row.id}`,
tenantId: row.tenantId,
chatId: row.chatId,
occurredAt: row.createdAt.toISOString(),
data: {
message: {
id: row.id,
clientMessageId: row.clientMessageId,
authorUserId: row.authorUserId,
body: row.body,
bodyFormat: row.bodyFormat,
parentMessageId: row.parentMessageId,
mentions: row.mentions,
attachmentIds: [...attachmentIds],
linkPreviews: row.linkPreviews,
createdAt: row.createdAt.toISOString(),
updatedAt: row.updatedAt.toISOString(),
editedAt: row.editedAt?.toISOString() ?? null,
deletedAt: row.deletedAt?.toISOString() ?? null,
...(row.bodyFormat === "system" ? { systemEvent: { kind: row.systemEventKind, metadata: row.systemEventMetadata } } : {}),
},
},
});
if (event.event !== CHAT_EVENT_NAMES.messageCreated) throw new Error("Stored audit chat message is invalid");
return event.data.message;
}
function normalizeAuditSession(session: ChatAuditSessionContext): ChatAuditSessionContext {
const sessionId = normalizeIdentifier(session.sessionId, "audit session id");
const reason = session.reason.trim().replace(/\s+/g, " ");
const expiresAt = new Date(session.expiresAtIso);
if (!reason || reason.length > 500 || reason.includes("\0") || Number.isNaN(expiresAt.getTime())) {
throw new Error("audit session is invalid");
}
return { sessionId, reason, expiresAtIso: expiresAt.toISOString() };
}
function normalizeAuditAttachmentVariant(value: string): ChatAuditAttachmentVariant {
if (value !== "original" && value !== "preview" && value !== "thumb") {
throw new CatalogError(foundationErrors.notFound, { attachment: "invalid-variant" });
}
return value;
}
function normalizeAuditMessageCursor(value: string | undefined, chatId: string): { createdAt: Date; id: string } | null {
try {
return parseChatMessageCursor(value, chatId);
} catch {
throw new CatalogError(chatErrors.invalidInput, { field: "beforeMessageCursor" });
}
}
function normalizeIdentifier(value: string, label: string): string {
const normalized = value.trim();
if (!normalized || normalized.length > 500 || normalized.includes("\0")) throw new Error(`${label} is invalid`);
return normalized;
}
function normalizeOptionalText(value: string | null): string | null {
const normalized = value?.trim() ?? "";
return normalized || null;
}