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

169 lines
8.2 KiB
TypeScript

// @vitest-environment node
import { createDbClient, getWriteDbClient } from "@hivegrid/db/client.server";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
import { listChatMessageDiscovery } from "./message-discovery.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_discovery_rls_tenant_a";
const TENANT_B = "chat_discovery_rls_tenant_b";
const VIEWER_A = "chat_discovery_rls_viewer_a";
const OUTSIDER_A = "chat_discovery_rls_outsider_a";
const MEMBER_B = "chat_discovery_rls_member_b";
const VISIBLE_CHAT = "chat_discovery_rls_visible";
const HIDDEN_CHAT = "chat_discovery_rls_hidden";
const ARCHIVED_CHAT = "chat_discovery_rls_archived";
const FOREIGN_CHAT = "chat_discovery_rls_foreign";
const ROLE_ID = "chat_discovery_rls_role";
const PERMISSION_ID = "chat_discovery_rls_permission";
const NEEDLE = "rls-visible-heat-pump";
describeIfDatabase("chat message discovery with restricted FORCE RLS", () => {
const admin = createDbClient({ connectionString: ADMIN_URL });
const app = getWriteDbClient();
let permissionCreatedByFixture = false;
beforeAll(async () => {
await cleanup(admin);
await admin.user.createMany({
data: [
{ id: VIEWER_A, email: "chat-discovery-viewer-a@example.test", firstName: "Viewer", lastName: "A", active: true },
{ id: OUTSIDER_A, email: "chat-discovery-outsider-a@example.test", firstName: "Outsider", lastName: "A", active: true },
{ id: MEMBER_B, email: "chat-discovery-member-b@example.test", firstName: "Member", lastName: "B", active: true },
],
});
await admin.tenant.createMany({
data: [
{ id: TENANT_A, slug: TENANT_A, name: "Chat discovery tenant A", active: true },
{ id: TENANT_B, slug: TENANT_B, name: "Chat discovery tenant B", active: true },
],
});
await admin.tenantUser.createMany({
data: [
{ id: "chat_discovery_rls_tu_viewer", tenantId: TENANT_A, userId: VIEWER_A, type: 0, joined: 1, status: 2 },
{ id: "chat_discovery_rls_tu_outsider", tenantId: TENANT_A, userId: OUTSIDER_A, type: 0, joined: 1, status: 2 },
{ id: "chat_discovery_rls_tu_member_b", tenantId: TENANT_B, userId: MEMBER_B, type: 0, joined: 1, status: 2 },
],
});
await admin.teamChat.createMany({
data: [
{ id: VISIBLE_CHAT, tenantId: TENANT_A, createdByUserId: VIEWER_A, kind: "group", name: "Visible", eventStreamId: `${VISIBLE_CHAT}_stream` },
{ id: HIDDEN_CHAT, tenantId: TENANT_A, createdByUserId: OUTSIDER_A, kind: "group", name: "Hidden", eventStreamId: `${HIDDEN_CHAT}_stream` },
{
id: ARCHIVED_CHAT,
tenantId: TENANT_A,
createdByUserId: VIEWER_A,
kind: "group",
name: "Archived",
eventStreamId: `${ARCHIVED_CHAT}_stream`,
archivedAt: new Date("2026-07-16T09:00:00.000Z"),
archivedReason: "manual",
},
{ id: FOREIGN_CHAT, tenantId: TENANT_B, createdByUserId: MEMBER_B, kind: "group", name: "Foreign", eventStreamId: `${FOREIGN_CHAT}_stream` },
],
});
await admin.teamChatMember.createMany({
data: [
{ id: "chat_discovery_rls_member_visible", tenantId: TENANT_A, chatId: VISIBLE_CHAT, userId: VIEWER_A, notificationPref: "all_messages" },
{ id: "chat_discovery_rls_member_hidden", tenantId: TENANT_A, chatId: HIDDEN_CHAT, userId: OUTSIDER_A, notificationPref: "all_messages" },
{ id: "chat_discovery_rls_member_archived", tenantId: TENANT_A, chatId: ARCHIVED_CHAT, userId: VIEWER_A, notificationPref: "all_messages" },
{ id: "chat_discovery_rls_member_foreign", tenantId: TENANT_B, chatId: FOREIGN_CHAT, userId: MEMBER_B, notificationPref: "all_messages" },
],
});
await admin.teamChatMessage.createMany({
data: [
message("chat_discovery_rls_message_visible", TENANT_A, VISIBLE_CHAT, VIEWER_A),
message("chat_discovery_rls_message_hidden", TENANT_A, HIDDEN_CHAT, OUTSIDER_A),
message("chat_discovery_rls_message_archived", TENANT_A, ARCHIVED_CHAT, VIEWER_A),
message("chat_discovery_rls_message_foreign", TENANT_B, FOREIGN_CHAT, MEMBER_B),
],
});
const existingPermission = await admin.permission.findUnique({ where: { name: CHAT_PERMISSIONS.readOwnChannels }, select: { id: true } });
permissionCreatedByFixture = existingPermission === null;
const permission =
existingPermission ??
(await admin.permission.create({
data: {
id: PERMISSION_ID,
name: CHAT_PERMISSIONS.readOwnChannels,
description: "Chat discovery RLS fixture",
type: "app",
isDefault: false,
order: 99_980,
},
select: { id: true },
}));
await admin.role.create({
data: {
id: ROLE_ID,
tenantId: null,
name: "Chat discovery RLS role",
description: "Restricted-role proof for chat search and mentions",
type: "app",
assignToNewUsers: false,
isDefault: false,
order: 99_980,
},
});
await admin.rolePermission.create({ data: { id: `${ROLE_ID}_permission`, roleId: ROLE_ID, permissionId: permission.id } });
await admin.userRole.create({ data: { id: `${ROLE_ID}_viewer`, tenantId: TENANT_A, userId: VIEWER_A, roleId: ROLE_ID } });
});
afterAll(async () => {
await cleanup(admin);
if (permissionCreatedByFixture) await admin.permission.deleteMany({ where: { id: PERMISSION_ID, name: CHAT_PERMISSIONS.readOwnChannels } });
await Promise.all([admin.$disconnect(), app.$disconnect()]);
});
it("returns search and mention results only from the viewer's active, non-archived member channel", async () => {
const role = await app.$queryRaw<Array<{ currentUser: string }>>`SELECT current_user AS "currentUser"`;
expect(role).toEqual([{ currentUser: "hivegrid_app" }]);
const state = await app.$queryRaw<Array<{ enabled: boolean; forced: boolean }>>`
SELECT relrowsecurity AS enabled, relforcerowsecurity AS forced
FROM pg_catalog.pg_class
WHERE relnamespace = 'public'::regnamespace
AND relname IN ('TeamChat', 'TeamChatMember', 'TeamChatMessage')
ORDER BY relname ASC
`;
expect(state).toHaveLength(3);
expect(state.every((table) => table.enabled && table.forced)).toBe(true);
await expect(app.teamChatMessage.findMany({ where: { body: { contains: NEEDLE } }, select: { id: true } })).resolves.toEqual([]);
const context = { tenantId: TENANT_A, userId: VIEWER_A, permissions: [CHAT_PERMISSIONS.readOwnChannels] } as const;
const search = await listChatMessageDiscovery({ ...context, mode: "search", query: NEEDLE });
const mentions = await listChatMessageDiscovery({ ...context, mode: "mentions" });
expect(search.messages.map(({ id }) => id)).toEqual(["chat_discovery_rls_message_visible"]);
expect(mentions.messages.map(({ id }) => id)).toEqual(["chat_discovery_rls_message_visible"]);
});
});
function message(id: string, tenantId: string, chatId: string, authorUserId: string) {
return {
id,
tenantId,
chatId,
authorUserId,
clientMessageId: `${id}_client`,
body: `${NEEDLE} ${id}`,
mentions: [{ type: "user", id: VIEWER_A, label: "Viewer A" }],
linkPreviews: [],
} as const;
}
async function cleanup(admin: ReturnType<typeof createDbClient>): Promise<void> {
await admin.userRole.deleteMany({ where: { id: `${ROLE_ID}_viewer` } });
await admin.rolePermission.deleteMany({ where: { id: `${ROLE_ID}_permission` } });
await admin.role.deleteMany({ where: { id: ROLE_ID } });
await admin.teamChatMessage.deleteMany({ where: { id: { startsWith: "chat_discovery_rls_message_" } } });
await admin.teamChatMember.deleteMany({ where: { id: { startsWith: "chat_discovery_rls_member_" } } });
await admin.teamChat.deleteMany({ where: { id: { in: [VISIBLE_CHAT, HIDDEN_CHAT, ARCHIVED_CHAT, FOREIGN_CHAT] } } });
await admin.tenantUser.deleteMany({ where: { id: { startsWith: "chat_discovery_rls_tu_" } } });
await admin.tenant.deleteMany({ where: { id: { in: [TENANT_A, TENANT_B] } } });
await admin.user.deleteMany({ where: { id: { in: [VIEWER_A, OUTSIDER_A, MEMBER_B] } } });
}