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

448 lines
16 KiB
TypeScript

// @vitest-environment node
import { createDbClient, getWriteDbClient } from "@hivegrid/db/client.server";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
import {
forceArchiveChatAuditChannel,
forceRemoveChatAuditMember,
forceSetChatAuditMemberRole,
getChatAuditChannelDetail,
listChatAuditChannels,
recordChatAuditSessionStarted,
} from "./audit.server.js";
import { CHAT_PERMISSIONS } from "./permissions.js";
const ADMIN_URL = process.env.RLS_TEST_DATABASE_URL;
const describeIfDatabase = ADMIN_URL ? describe : describe.skip;
const TENANT_A = "chat_audit_rls_tenant_a";
const TENANT_B = "chat_audit_rls_tenant_b";
const AUDITOR_A = "chat_audit_rls_auditor_a";
const MEMBER_A = "chat_audit_rls_member_a";
const MEMBER_B = "chat_audit_rls_member_b";
const CHAT_A = "chat_audit_rls_channel_a";
const CHAT_B = "chat_audit_rls_channel_b";
const MESSAGE_A = "chat_audit_rls_message_a";
const MESSAGE_B = "chat_audit_rls_message_b";
const ROLE_ID = "chat_audit_rls_role";
const READ_OWN_PERMISSION_ID = "chat_audit_rls_read_own_permission";
const READ_ALL_PERMISSION_ID = "chat_audit_rls_read_all_permission";
const ADMIN_PERMISSION_ID = "chat_audit_rls_admin_permission";
const READ_OWN_ROLE_PERMISSION_ID = "chat_audit_rls_role_read_own";
const READ_ALL_ROLE_PERMISSION_ID = "chat_audit_rls_role_read_all";
const ADMIN_ROLE_PERMISSION_ID = "chat_audit_rls_role_admin";
const USER_ROLE_ID = "chat_audit_rls_user_role";
const SESSION_ID = "chat_audit_rls_session";
const LIST_REQUEST_ID = "chat_audit_rls_list_request";
const SESSION_REQUEST_ID = "chat_audit_rls_session_request";
const OPEN_REQUEST_ID = "chat_audit_rls_open_request";
const ROLE_REQUEST_ID = "chat_audit_rls_role_request";
const REMOVE_REQUEST_ID = "chat_audit_rls_remove_request";
const ARCHIVE_REQUEST_ID = "chat_audit_rls_archive_request";
const AUDIT_REASON = "Kundensupport-Fall 4711 pruefen";
const STALE_ROUTE_PERMISSIONS = [CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.readAllChannels, CHAT_PERMISSIONS.admin] as const;
describeIfDatabase("chat admin audit with restricted FORCE RLS", () => {
const admin = createDbClient({ connectionString: ADMIN_URL });
const app = getWriteDbClient();
let createdReadOwnPermission = false;
let createdReadAllPermission = false;
let createdAdminPermission = false;
beforeAll(async () => {
await cleanup(admin);
await admin.user.createMany({
data: [
{
id: AUDITOR_A,
email: "chat-audit-auditor-a@example.test",
firstName: "Audit",
lastName: "Admin",
active: true,
},
{
id: MEMBER_A,
email: "chat-audit-member-a@example.test",
firstName: "Member",
lastName: "A",
active: true,
},
{
id: MEMBER_B,
email: "chat-audit-member-b@example.test",
firstName: "Member",
lastName: "B",
active: true,
},
],
});
await admin.tenant.createMany({
data: [
{ id: TENANT_A, slug: TENANT_A, name: "Chat audit RLS tenant A", active: true },
{ id: TENANT_B, slug: TENANT_B, name: "Chat audit RLS tenant B", active: true },
],
});
await admin.tenantUser.createMany({
data: [
{ id: "chat_audit_rls_tu_auditor_a", tenantId: TENANT_A, userId: AUDITOR_A, type: 0, joined: 1, status: 2 },
{ id: "chat_audit_rls_tu_member_a", tenantId: TENANT_A, userId: MEMBER_A, type: 0, joined: 1, status: 2 },
{ id: "chat_audit_rls_tu_member_b", tenantId: TENANT_B, userId: MEMBER_B, type: 0, joined: 1, status: 2 },
],
});
await admin.teamChat.createMany({
data: [
{
id: CHAT_A,
tenantId: TENANT_A,
createdByUserId: MEMBER_A,
kind: "dm",
name: null,
isPrivate: true,
eventStreamId: "chat_audit_rls_stream_a",
dmPairKey: "chat_audit_rls_pair_a",
lastMessageAt: new Date("2026-07-16T10:00:00.000Z"),
},
{
id: CHAT_B,
tenantId: TENANT_B,
createdByUserId: MEMBER_B,
kind: "group",
name: "Foreign tenant channel",
isPrivate: true,
eventStreamId: "chat_audit_rls_stream_b",
lastMessageAt: new Date("2026-07-16T11:00:00.000Z"),
},
],
});
await admin.teamChatMember.createMany({
data: [
{
id: "chat_audit_rls_member_row_a",
tenantId: TENANT_A,
chatId: CHAT_A,
userId: MEMBER_A,
notificationPref: "all_messages",
},
{
id: "chat_audit_rls_member_row_b",
tenantId: TENANT_B,
chatId: CHAT_B,
userId: MEMBER_B,
notificationPref: "all_messages",
},
],
});
await admin.teamChatMessage.createMany({
data: [
{
id: MESSAGE_A,
tenantId: TENANT_A,
chatId: CHAT_A,
authorUserId: MEMBER_A,
clientMessageId: `${MESSAGE_A}_client`,
body: "Tenant A confidential audit message",
mentions: [],
linkPreviews: [],
},
{
id: MESSAGE_B,
tenantId: TENANT_B,
chatId: CHAT_B,
authorUserId: MEMBER_B,
clientMessageId: `${MESSAGE_B}_client`,
body: "Tenant B must stay invisible",
mentions: [],
linkPreviews: [],
},
],
});
const readOwnPermission = await ensurePermission(admin, CHAT_PERMISSIONS.readOwnChannels, READ_OWN_PERMISSION_ID, 99_970);
createdReadOwnPermission = readOwnPermission.created;
const readAllPermission = await ensurePermission(admin, CHAT_PERMISSIONS.readAllChannels, READ_ALL_PERMISSION_ID, 99_971);
createdReadAllPermission = readAllPermission.created;
const adminPermission = await ensurePermission(admin, CHAT_PERMISSIONS.admin, ADMIN_PERMISSION_ID, 99_972);
createdAdminPermission = adminPermission.created;
await admin.role.create({
data: {
id: ROLE_ID,
tenantId: null,
name: "Chat audit RLS role",
description: "Restricted-role proof for chat admin audit",
type: "app",
assignToNewUsers: false,
isDefault: false,
order: 99_970,
},
});
await admin.rolePermission.createMany({
data: [
{ id: READ_OWN_ROLE_PERMISSION_ID, roleId: ROLE_ID, permissionId: readOwnPermission.id },
{ id: READ_ALL_ROLE_PERMISSION_ID, roleId: ROLE_ID, permissionId: readAllPermission.id },
{ id: ADMIN_ROLE_PERMISSION_ID, roleId: ROLE_ID, permissionId: adminPermission.id },
],
});
await admin.userRole.create({
data: { id: USER_ROLE_ID, tenantId: TENANT_A, userId: AUDITOR_A, roleId: ROLE_ID },
});
});
afterAll(async () => {
await cleanup(admin);
if (createdReadOwnPermission) {
await admin.permission.deleteMany({
where: { id: READ_OWN_PERMISSION_ID, name: CHAT_PERMISSIONS.readOwnChannels },
});
}
if (createdReadAllPermission) {
await admin.permission.deleteMany({
where: { id: READ_ALL_PERMISSION_ID, name: CHAT_PERMISSIONS.readAllChannels },
});
}
if (createdAdminPermission) {
await admin.permission.deleteMany({
where: { id: ADMIN_PERMISSION_ID, name: CHAT_PERMISSIONS.admin },
});
}
await Promise.all([admin.$disconnect(), app.$disconnect()]);
});
it("reads every channel in its own tenant, records every audit access, and rechecks revoked permission", async () => {
const role = await app.$queryRaw<Array<{ currentUser: string }>>`SELECT current_user AS "currentUser"`;
expect(role).toEqual([{ currentUser: "hivegrid_app" }]);
const rlsState = await app.$queryRaw<Array<{ tableName: string; enabled: boolean; forced: boolean }>>`
SELECT relname AS "tableName", relrowsecurity AS enabled, relforcerowsecurity AS forced
FROM pg_catalog.pg_class
WHERE relnamespace = 'public'::regnamespace
AND relname IN ('TeamChat', 'TeamChatMember', 'TeamChatMessage', 'OutboxEvent')
ORDER BY relname ASC
`;
expect(rlsState).toHaveLength(4);
expect(rlsState.every((table) => table.enabled && table.forced)).toBe(true);
await expect(app.teamChat.findMany({ select: { id: true } })).resolves.toEqual([]);
await expect(app.teamChatMessage.findMany({ select: { id: true } })).resolves.toEqual([]);
const context = {
tenantId: TENANT_A,
userId: AUDITOR_A,
permissions: STALE_ROUTE_PERMISSIONS,
} as const;
const auditSession = {
sessionId: SESSION_ID,
reason: AUDIT_REASON,
expiresAtIso: "2026-07-16T10:15:00.000Z",
} as const;
const channels = await listChatAuditChannels({
...context,
requestId: LIST_REQUEST_ID,
auditSession,
});
expect(channels.map(({ id }) => id)).toEqual([CHAT_A]);
expect(channels[0]).toMatchObject({
kind: "dm",
memberCount: 1,
participants: [{ userId: MEMBER_A, displayName: "Member A", avatarUrl: null }],
});
await recordChatAuditSessionStarted({
...context,
requestId: SESSION_REQUEST_ID,
auditSession,
});
await expect(
getChatAuditChannelDetail({
...context,
chatId: CHAT_B,
requestId: "chat_audit_rls_foreign_open_request",
auditSession,
})
).rejects.toMatchObject({ code: "foundation.not_found" });
await expect(
forceArchiveChatAuditChannel({
...context,
chatId: CHAT_B,
requestId: "chat_audit_rls_foreign_archive_request",
auditSession,
})
).rejects.toMatchObject({ code: "foundation.not_found" });
const detail = await getChatAuditChannelDetail({
...context,
chatId: CHAT_A,
requestId: OPEN_REQUEST_ID,
auditSession,
});
expect(detail).toMatchObject({
channel: {
id: CHAT_A,
kind: "dm",
member: { canWrite: false, notificationPreference: "muted" },
},
messages: [{ id: MESSAGE_A, body: "Tenant A confidential audit message" }],
readReceipts: [],
messageFeatures: [],
});
await forceSetChatAuditMemberRole({
...context,
chatId: CHAT_A,
memberUserId: MEMBER_A,
roleInChat: "admin",
requestId: ROLE_REQUEST_ID,
auditSession,
});
await forceRemoveChatAuditMember({
...context,
chatId: CHAT_A,
memberUserId: MEMBER_A,
requestId: REMOVE_REQUEST_ID,
auditSession,
});
await forceArchiveChatAuditChannel({
...context,
chatId: CHAT_A,
requestId: ARCHIVE_REQUEST_ID,
auditSession,
});
await expect(
admin.teamChatMember.findUnique({
where: { chatId_userId: { chatId: CHAT_A, userId: MEMBER_A } },
select: { leftAt: true, writeRevokedAt: true, isManualMember: true, isProjectManaged: true, isGroupManaged: true },
})
).resolves.toMatchObject({
leftAt: expect.any(Date),
writeRevokedAt: expect.any(Date),
isManualMember: false,
isProjectManaged: false,
isGroupManaged: false,
});
await expect(admin.teamChat.findUnique({ where: { id: CHAT_A }, select: { archivedAt: true, archivedReason: true } })).resolves.toMatchObject({
archivedAt: expect.any(Date),
archivedReason: "manual",
});
const outboxRows = await admin.outboxEvent.findMany({
where: {
tenantId: TENANT_A,
eventType: "audit.event.create",
OR: [
{ payload: { path: ["requestId"], equals: SESSION_REQUEST_ID } },
{ payload: { path: ["requestId"], equals: LIST_REQUEST_ID } },
{ payload: { path: ["requestId"], equals: OPEN_REQUEST_ID } },
{ payload: { path: ["requestId"], equals: ROLE_REQUEST_ID } },
{ payload: { path: ["requestId"], equals: REMOVE_REQUEST_ID } },
{ payload: { path: ["requestId"], equals: ARCHIVE_REQUEST_ID } },
],
},
orderBy: { createdAt: "asc" },
select: { payload: true },
});
expect(outboxRows).toHaveLength(6);
expect(outboxRows.map(({ payload }) => payload)).toEqual([
expect.objectContaining({
action: "chat.audit.channel_listed",
requestId: LIST_REQUEST_ID,
metadata: expect.objectContaining({ auditSessionId: SESSION_ID, reason: AUDIT_REASON, readOnly: true }),
}),
expect.objectContaining({
action: "chat.audit.session_started",
requestId: SESSION_REQUEST_ID,
metadata: expect.objectContaining({ auditSessionId: SESSION_ID, reason: AUDIT_REASON, readOnly: true }),
}),
expect.objectContaining({
action: "chat.audit.channel_opened",
requestId: OPEN_REQUEST_ID,
targetId: CHAT_A,
dataSensitivity: "confidential",
metadata: expect.objectContaining({ auditSessionId: SESSION_ID, reason: AUDIT_REASON, readOnly: true }),
}),
expect.objectContaining({
action: "chat.audit.member_role_forced",
requestId: ROLE_REQUEST_ID,
metadata: expect.objectContaining({ auditSessionId: SESSION_ID, reason: AUDIT_REASON, memberUserId: MEMBER_A, roleInChat: "admin" }),
}),
expect.objectContaining({
action: "chat.audit.member_removed",
requestId: REMOVE_REQUEST_ID,
metadata: expect.objectContaining({ auditSessionId: SESSION_ID, reason: AUDIT_REASON, memberUserId: MEMBER_A }),
}),
expect.objectContaining({
action: "chat.audit.channel_archived",
requestId: ARCHIVE_REQUEST_ID,
metadata: expect.objectContaining({ auditSessionId: SESSION_ID, reason: AUDIT_REASON, channelId: CHAT_A }),
}),
]);
await expect(
admin.outboxEvent.count({
where: {
tenantId: TENANT_B,
eventType: "audit.event.create",
payload: { path: ["requestId"], equals: OPEN_REQUEST_ID },
},
})
).resolves.toBe(0);
await admin.rolePermission.delete({ where: { id: ADMIN_ROLE_PERMISSION_ID } });
await expect(
forceArchiveChatAuditChannel({
...context,
chatId: CHAT_A,
requestId: "chat_audit_rls_revoked_admin_request",
auditSession,
})
).rejects.toMatchObject({ code: "foundation.not_found" });
await admin.rolePermission.delete({ where: { id: READ_ALL_ROLE_PERMISSION_ID } });
await expect(
listChatAuditChannels({
...context,
requestId: "chat_audit_rls_revoked_list_request",
auditSession,
})
).rejects.toMatchObject({ code: "foundation.not_found" });
});
});
async function ensurePermission(
admin: ReturnType<typeof createDbClient>,
name: string,
fixtureId: string,
order: number
): Promise<{ id: string; created: boolean }> {
const existing = await admin.permission.findUnique({ where: { name }, select: { id: true } });
if (existing) return { id: existing.id, created: false };
const created = await admin.permission.create({
data: {
id: fixtureId,
name,
description: "Chat admin audit RLS fixture",
type: "app",
isDefault: false,
order,
},
select: { id: true },
});
return { id: created.id, created: true };
}
async function cleanup(admin: ReturnType<typeof createDbClient>): Promise<void> {
await admin.outboxEvent.deleteMany({ where: { tenantId: { in: [TENANT_A, TENANT_B] } } });
await admin.userRole.deleteMany({ where: { id: USER_ROLE_ID } });
await admin.rolePermission.deleteMany({
where: { id: { in: [READ_OWN_ROLE_PERMISSION_ID, READ_ALL_ROLE_PERMISSION_ID, ADMIN_ROLE_PERMISSION_ID] } },
});
await admin.role.deleteMany({ where: { id: ROLE_ID } });
await admin.teamChatMessage.deleteMany({ where: { id: { in: [MESSAGE_A, MESSAGE_B] } } });
await admin.teamChatEvent.deleteMany({ where: { tenantId: { in: [TENANT_A, TENANT_B] } } });
await admin.teamChatMember.deleteMany({ where: { id: { in: ["chat_audit_rls_member_row_a", "chat_audit_rls_member_row_b"] } } });
await admin.teamChat.deleteMany({ where: { id: { in: [CHAT_A, CHAT_B] } } });
await admin.tenantUser.deleteMany({
where: { id: { in: ["chat_audit_rls_tu_auditor_a", "chat_audit_rls_tu_member_a", "chat_audit_rls_tu_member_b"] } },
});
await admin.tenant.deleteMany({ where: { id: { in: [TENANT_A, TENANT_B] } } });
await admin.user.deleteMany({ where: { id: { in: [AUDITOR_A, MEMBER_A, MEMBER_B] } } });
}