169 lines
8.2 KiB
TypeScript
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] } } });
|
|
}
|