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

224 lines
8.3 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";
/**
* This suite must run against the restricted runtime role. Ordinary unit runs
* skip it because a mocked client cannot prove FORCE RLS or policy WITH CHECK
* behavior. `verify:rls-live` owns the ephemeral database and both URLs.
*/
const ADMIN_URL = process.env.RLS_TEST_DATABASE_URL;
const describeIfDatabase = ADMIN_URL ? describe : describe.skip;
const TENANT_A = "chat_system_rls_tenant_a";
const TENANT_B = "chat_system_rls_tenant_b";
const USER_A = "chat_system_rls_user_a";
const USER_B = "chat_system_rls_user_b";
const PIPELINE_A = "chat_system_rls_pipeline_a";
const STAGE_A = "chat_system_rls_stage_a";
const PROJECT_A = "chat_system_rls_project_a";
const GROUP_A = "chat_system_rls_group_a";
const GROUP_B = "chat_system_rls_group_b";
const CHAT_A = "chat_system_rls_project_channel_a";
const MESSAGE_A = "chat_system_rls_message_a";
const GROUP_SOURCE_A = "chat_system_rls_group_source_a";
const CROSS_TENANT_GROUP_SOURCE = "chat_system_rls_cross_tenant_group_source";
describeIfDatabase("chat system ownership with the restricted app role", () => {
const admin = createDbClient({ connectionString: ADMIN_URL });
const app = getWriteDbClient();
beforeAll(async () => {
await cleanupFixtures(admin);
await admin.user.createMany({
data: [
{ id: USER_A, email: "chat-system-rls-a@example.test", firstName: "System", lastName: "A", active: true },
{ id: USER_B, email: "chat-system-rls-b@example.test", firstName: "System", lastName: "B", active: true },
],
});
await admin.tenant.createMany({
data: [
{ id: TENANT_A, slug: TENANT_A, name: "Chat system RLS tenant A", active: true },
{ id: TENANT_B, slug: TENANT_B, name: "Chat system RLS tenant B", active: true },
],
});
await admin.tenantUser.createMany({
data: [
{ id: "chat_system_rls_tenant_user_a", tenantId: TENANT_A, userId: USER_A, type: 0, joined: 1, status: 2 },
{ id: "chat_system_rls_tenant_user_b", tenantId: TENANT_B, userId: USER_B, type: 0, joined: 1, status: 2 },
],
});
await admin.pipeline.create({
data: {
id: PIPELINE_A,
tenantId: TENANT_A,
createdByUserId: USER_A,
name: "Chat system RLS pipeline",
typHint: "auftrag",
},
});
await admin.pipelineStage.create({
data: {
id: STAGE_A,
tenantId: TENANT_A,
pipelineId: PIPELINE_A,
name: "Active",
stageKind: "offen",
},
});
await admin.projekt.create({
data: {
id: PROJECT_A,
tenantId: TENANT_A,
createdByUserId: USER_A,
projektNummer: "CHAT-SYSTEM-RLS-001",
projektname: "System-created project channel proof",
pipelineId: PIPELINE_A,
stageId: STAGE_A,
},
});
await admin.group.createMany({
data: [
{
id: GROUP_A,
tenantId: TENANT_A,
createdByUserId: USER_A,
name: "Same-tenant group",
description: "Allowed chat source",
color: 1,
},
{
id: GROUP_B,
tenantId: TENANT_B,
createdByUserId: USER_B,
name: "Foreign-tenant group",
description: "Denied chat source",
color: 2,
},
],
});
});
afterAll(async () => {
await cleanupFixtures(admin);
await Promise.all([admin.$disconnect(), app.$disconnect()]);
});
it("allows actorless project records and rejects a cross-tenant group source through FORCE RLS", async () => {
const currentRole = await app.$queryRaw<Array<{ currentUser: string }>>`SELECT current_user AS "currentUser"`;
expect(currentRole).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', 'TeamChatMessage', 'TeamChatGroupSource', 'Group')
ORDER BY relname ASC
`;
expect(rlsState).toHaveLength(4);
expect(rlsState.every((table) => table.enabled && table.forced)).toBe(true);
// The restricted role sees no tenant rows without a bound identity.
await expect(app.teamChat.findMany({ where: { id: CHAT_A }, select: { id: true } })).resolves.toEqual([]);
const created = await runWithRlsContext({ tenantId: TENANT_A, userId: USER_A }, () =>
app.$transaction(async (tx) => {
const chat = await tx.teamChat.create({
data: {
id: CHAT_A,
tenantId: TENANT_A,
createdByUserId: null,
kind: "project",
name: "System project channel",
projektId: PROJECT_A,
isPrivate: true,
eventStreamId: "chat_system_rls_stream_a",
},
select: { id: true, tenantId: true, createdByUserId: true, projektId: true },
});
const message = await tx.teamChatMessage.create({
data: {
id: MESSAGE_A,
tenantId: TENANT_A,
chatId: CHAT_A,
authorUserId: null,
clientMessageId: "system:project-created:chat-system-rls",
body: "",
bodyFormat: "system",
parentMessageId: null,
mentions: [],
linkPreviews: [],
systemEventKey: "project-created:chat-system-rls",
systemEventKind: "project_created",
systemEventMetadata: {
projectId: PROJECT_A,
projectName: "System-created project channel proof",
},
},
select: {
id: true,
tenantId: true,
authorUserId: true,
bodyFormat: true,
systemEventKind: true,
systemEventMetadata: true,
},
});
const groupSource = await tx.teamChatGroupSource.create({
data: {
id: GROUP_SOURCE_A,
tenantId: TENANT_A,
chatId: CHAT_A,
groupId: GROUP_A,
syncEnabled: true,
},
select: { id: true, tenantId: true, chatId: true, groupId: true },
});
return { chat, message, groupSource };
})
);
expect(created.chat).toEqual({ id: CHAT_A, tenantId: TENANT_A, createdByUserId: null, projektId: PROJECT_A });
expect(created.message).toEqual({
id: MESSAGE_A,
tenantId: TENANT_A,
authorUserId: null,
bodyFormat: "system",
systemEventKind: "project_created",
systemEventMetadata: {
projectId: PROJECT_A,
projectName: "System-created project channel proof",
},
});
expect(created.groupSource).toEqual({ id: GROUP_SOURCE_A, tenantId: TENANT_A, chatId: CHAT_A, groupId: GROUP_A });
await expect(
runWithRlsContext({ tenantId: TENANT_A, userId: USER_A }, () =>
app.teamChatGroupSource.create({
data: {
id: CROSS_TENANT_GROUP_SOURCE,
tenantId: TENANT_A,
chatId: CHAT_A,
groupId: GROUP_B,
syncEnabled: true,
},
})
)
).rejects.toThrow();
await expect(admin.teamChatGroupSource.count({ where: { id: CROSS_TENANT_GROUP_SOURCE } })).resolves.toBe(0);
});
});
async function cleanupFixtures(admin: ReturnType<typeof createDbClient>): Promise<void> {
await admin.teamChatGroupSource.deleteMany({ where: { id: { in: [GROUP_SOURCE_A, CROSS_TENANT_GROUP_SOURCE] } } });
await admin.teamChatMessage.deleteMany({ where: { id: MESSAGE_A } });
await admin.teamChat.deleteMany({ where: { id: CHAT_A } });
await admin.group.deleteMany({ where: { id: { in: [GROUP_A, GROUP_B] } } });
await admin.projekt.deleteMany({ where: { id: PROJECT_A } });
await admin.pipelineStage.deleteMany({ where: { id: STAGE_A } });
await admin.pipeline.deleteMany({ where: { id: PIPELINE_A } });
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] } } });
}