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 { 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 { 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 { 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 { 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 { 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 { 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 { 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> = { "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(input: ChatRouteRepositoryContext, operation: (tx: DbTransactionClient) => Promise): Promise { 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 { 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, normalized: NormalizedAuditAdminMutation, channel: AuditChannelMutationRow, event: Readonly<{ action: ChatAuditActivityAction; targetType: string; targetId: string; metadata: Record; summaryText: string; }> ): Promise { 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 { 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 { 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 { const grouped = new Map(); 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 { 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 { if (chatIds.length === 0) return []; return tx.$queryRaw` 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 { const result = new Map(); 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; }