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

102 lines
4.9 KiB
TypeScript

// @vitest-environment node
import { createDbClient, getWriteDbClient } from "@hivegrid/db/client.server";
import { runWithRlsContext } from "@hivegrid/db/rls-context.server";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
const ADMIN_URL = process.env.RLS_TEST_DATABASE_URL;
const describeIfDatabase = ADMIN_URL ? describe : describe.skip;
const TENANT_A = "chat_mutation_rls_tenant_a";
const TENANT_B = "chat_mutation_rls_tenant_b";
const USER_A = "chat_mutation_rls_user_a";
const USER_B = "chat_mutation_rls_user_b";
const CHAT_A = "chat_mutation_rls_chat_a";
const CHAT_B = "chat_mutation_rls_chat_b";
const MESSAGE_A = "chat_mutation_rls_message_a";
const MESSAGE_B = "chat_mutation_rls_message_b";
describeIfDatabase("chat message mutations with the restricted app role", () => {
const admin = createDbClient({ connectionString: ADMIN_URL });
const app = getWriteDbClient();
beforeAll(async () => {
await cleanup(admin);
await admin.user.createMany({
data: [
{ id: USER_A, email: "chat-mutation-rls-a@example.test", firstName: "Mutation", lastName: "A", active: true },
{ id: USER_B, email: "chat-mutation-rls-b@example.test", firstName: "Mutation", lastName: "B", active: true },
],
});
await admin.tenant.createMany({
data: [
{ id: TENANT_A, slug: TENANT_A, name: "Chat mutation A", active: true },
{ id: TENANT_B, slug: TENANT_B, name: "Chat mutation B", active: true },
],
});
await admin.tenantUser.createMany({
data: [
{ id: "chat_mutation_rls_membership_a", tenantId: TENANT_A, userId: USER_A, type: 0, joined: 1, status: 2 },
{ id: "chat_mutation_rls_membership_b", tenantId: TENANT_B, userId: USER_B, type: 0, joined: 1, status: 2 },
],
});
await admin.teamChat.createMany({
data: [
{ id: CHAT_A, tenantId: TENANT_A, createdByUserId: USER_A, kind: "group", name: "A", eventStreamId: "chat_mutation_rls_stream_a" },
{ id: CHAT_B, tenantId: TENANT_B, createdByUserId: USER_B, kind: "group", name: "B", eventStreamId: "chat_mutation_rls_stream_b" },
],
});
await admin.teamChatMember.createMany({
data: [
{ id: "chat_mutation_rls_chat_member_a", tenantId: TENANT_A, chatId: CHAT_A, userId: USER_A, notificationPref: "all_messages" },
{ id: "chat_mutation_rls_chat_member_b", tenantId: TENANT_B, chatId: CHAT_B, userId: USER_B, notificationPref: "all_messages" },
],
});
await admin.teamChatMessage.createMany({
data: [
{ id: MESSAGE_A, tenantId: TENANT_A, chatId: CHAT_A, authorUserId: USER_A, clientMessageId: "chat-mutation-a", body: "A", mentions: [], linkPreviews: [] },
{ id: MESSAGE_B, tenantId: TENANT_B, chatId: CHAT_B, authorUserId: USER_B, clientMessageId: "chat-mutation-b", body: "B", mentions: [], linkPreviews: [] },
],
});
});
afterAll(async () => {
await cleanup(admin);
await Promise.all([admin.$disconnect(), app.$disconnect()]);
});
it("permits a same-tenant tombstone but cannot update a foreign message", async () => {
const currentRole = await app.$queryRaw<Array<{ currentUser: string }>>`SELECT current_user AS "currentUser"`;
expect(currentRole).toEqual([{ currentUser: "hivegrid_app" }]);
await expect(app.teamChatMessage.findMany({ where: { id: MESSAGE_A }, select: { id: true } })).resolves.toEqual([]);
const deletedAt = new Date("2026-07-16T09:00:00.000Z");
const sameTenant = await runWithRlsContext({ tenantId: TENANT_A, userId: USER_A }, () =>
app.teamChatMessage.updateMany({
where: { id: MESSAGE_A, tenantId: TENANT_A, chatId: CHAT_A },
data: { body: "", mentions: [], linkPreviews: [], deletedAt, deletedByUserId: USER_A },
})
);
expect(sameTenant.count).toBe(1);
const foreign = await runWithRlsContext({ tenantId: TENANT_A, userId: USER_A }, () =>
app.teamChatMessage.updateMany({ where: { id: MESSAGE_B }, data: { body: "cross-tenant write" } })
);
expect(foreign.count).toBe(0);
await expect(admin.teamChatMessage.findUnique({ where: { id: MESSAGE_B }, select: { body: true } })).resolves.toEqual({ body: "B" });
await expect(admin.teamChatMessage.findUnique({ where: { id: MESSAGE_A }, select: { body: true, deletedAt: true, deletedByUserId: true } })).resolves.toEqual({
body: "",
deletedAt,
deletedByUserId: USER_A,
});
});
});
async function cleanup(admin: ReturnType<typeof createDbClient>): Promise<void> {
await admin.teamChatMessage.deleteMany({ where: { id: { in: [MESSAGE_A, MESSAGE_B] } } });
await admin.teamChatMember.deleteMany({ where: { tenantId: { in: [TENANT_A, TENANT_B] } } });
await admin.teamChat.deleteMany({ where: { id: { in: [CHAT_A, CHAT_B] } } });
await admin.tenantUser.deleteMany({ where: { tenantId: { in: [TENANT_A, TENANT_B] } } });
await admin.tenant.deleteMany({ where: { id: { in: [TENANT_A, TENANT_B] } } });
await admin.user.deleteMany({ where: { id: { in: [USER_A, USER_B] } } });
}