Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/chat/src/project-sync.server.test.ts
T

637 lines
23 KiB
TypeScript

import type { DbTransactionClient } from "@hivegrid/db/transactions.server";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
logActivity: vi.fn(),
publishAuditEventViaOutbox: vi.fn(),
publishRealtimeWakeup: vi.fn(),
tenantHasChatModuleForSystemTx: vi.fn(),
writeSystemMessage: vi.fn(),
tx: {
$executeRaw: vi.fn(),
projekt: { findFirst: vi.fn() },
projektMitglied: { findMany: vi.fn() },
group: { findMany: vi.fn() },
tenantUser: { findMany: vi.fn() },
teamChat: { findFirst: vi.fn(), create: vi.fn(), updateMany: vi.fn() },
teamChatMember: { findMany: vi.fn(), create: vi.fn(), updateMany: vi.fn() },
teamChatEvent: { create: vi.fn() },
},
}));
vi.mock("@hivegrid/activity", () => ({
logActivity: mocks.logActivity,
}));
vi.mock("@hivegrid/db/audit-events.server", () => ({
publishAuditEventViaOutbox: mocks.publishAuditEventViaOutbox,
}));
vi.mock("./module-access.server.js", () => ({
tenantHasChatModuleForSystemTx: (...args: unknown[]) => mocks.tenantHasChatModuleForSystemTx(...args),
}));
vi.mock("./realtime-wakeup.server.js", () => ({
publishChatPersistentRealtimeWakeup: (...args: unknown[]) => mocks.publishRealtimeWakeup(...args),
}));
vi.mock("./system-message.server.js", () => ({
writeChatSystemMessageWithTx: (...args: unknown[]) => mocks.writeSystemMessage(...args),
}));
import { archiveProjectChannelIfEnabledWithTx, ensureAndSyncProjectChannelWithTx } from "./project-sync.server.js";
const NOW = new Date("2026-07-16T08:00:00.000Z");
const CHANNEL = {
id: "chat_project_1",
eventStreamId: "stream_project_1",
name: "Wärmepumpe Müller",
description: "Projekt-Chat für Wärmepumpe Müller, P-2026-0042",
isDemoData: false,
notificationDefault: "all_messages" as const,
};
const BASE_PROJECT = {
id: "project_1",
projektname: "Wärmepumpe Müller",
projektNummer: "P-2026-0042",
projektleiterId: "user_pl",
zustaendigePersonId: null,
isDemoData: false,
};
const TX = mocks.tx as unknown as DbTransactionClient;
describe("project channel synchronization", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.useFakeTimers();
vi.setSystemTime(NOW);
mocks.tx.$executeRaw.mockResolvedValue(1);
mocks.tenantHasChatModuleForSystemTx.mockResolvedValue(true);
mocks.tx.projekt.findFirst.mockResolvedValue(BASE_PROJECT);
mocks.tx.projektMitglied.findMany.mockResolvedValue([]);
mocks.tx.group.findMany.mockResolvedValue([]);
mocks.tx.tenantUser.findMany.mockResolvedValue([tenantUser("user_pl")]);
mocks.tx.teamChat.findFirst.mockResolvedValue(CHANNEL);
mocks.tx.teamChat.create.mockResolvedValue(CHANNEL);
mocks.tx.teamChat.updateMany.mockResolvedValue({ count: 1 });
mocks.tx.teamChatMember.findMany.mockResolvedValue([]);
mocks.tx.teamChatMember.create.mockResolvedValue({ id: "chat_member_1" });
mocks.tx.teamChatMember.updateMany.mockResolvedValue({ count: 1 });
mocks.tx.teamChatEvent.create.mockImplementation(async ({ data }: { data: Record<string, unknown> }) => ({
...data,
sequence: BigInt(mocks.tx.teamChatEvent.create.mock.calls.length),
occurredAt: NOW,
}));
mocks.logActivity.mockResolvedValue({ id: "activity_1" });
mocks.publishAuditEventViaOutbox.mockResolvedValue(undefined);
mocks.publishRealtimeWakeup.mockResolvedValue(undefined);
mocks.writeSystemMessage.mockImplementation(async (_tx: unknown, input: { tenantId: string; chatId: string; requestId: string }) => ({
replayed: false,
event: realtimeSystemEvent(input),
}));
});
afterEach(() => {
vi.useRealTimers();
});
it("creates one tenant-scoped project channel and unions all active effective members", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({
...BASE_PROJECT,
zustaendigePersonId: "user_responsible",
});
mocks.tx.projektMitglied.findMany.mockResolvedValue([
{ userId: "user_direct", groupId: null },
{ userId: "user_pl", groupId: null },
{ userId: "user_inactive", groupId: null },
{ userId: null, groupId: "group_1" },
]);
mocks.tx.group.findMany.mockResolvedValue([{ users: [{ userId: "user_group" }, { userId: "user_direct" }, { userId: "user_outside_tenant" }] }]);
mocks.tx.tenantUser.findMany.mockResolvedValue([
tenantUser("user_responsible"),
tenantUser("user_group"),
tenantUser("user_pl"),
tenantUser("user_direct"),
]);
mocks.tx.teamChat.findFirst.mockResolvedValue(null);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
actorUserId: null,
requestId: "request_create",
});
expect(result).toMatchObject({
chatId: CHANNEL.id,
created: true,
reactivated: false,
changed: true,
effectiveUserIds: ["user_direct", "user_group", "user_pl", "user_responsible"],
writeRestoredUserIds: ["user_direct", "user_group", "user_pl", "user_responsible"],
});
expect(mocks.tx.teamChat.create).toHaveBeenCalledWith({
data: expect.objectContaining({
tenantId: "tenant_1",
createdByUserId: null,
kind: "project",
projektId: "project_1",
isPrivate: true,
description: "Projekt-Chat für Wärmepumpe Müller, P-2026-0042",
isDemoData: false,
}),
select: { id: true, eventStreamId: true, name: true, description: true, isDemoData: true, notificationDefault: true },
});
expect(mocks.tx.teamChatMember.create).toHaveBeenCalledTimes(4);
const createdMembers = mocks.tx.teamChatMember.create.mock.calls.map((call) => call[0].data);
expect(createdMembers).toEqual(
expect.arrayContaining([
expect.objectContaining({
userId: "user_pl",
roleInChat: "admin",
isProjectManaged: true,
projectRoleInChat: "admin",
isManualMember: false,
manualRoleInChat: null,
}),
expect.objectContaining({
userId: "user_direct",
roleInChat: "member",
isProjectManaged: true,
projectRoleInChat: "member",
isManualMember: false,
}),
expect.objectContaining({ userId: "user_group", roleInChat: "member", isProjectManaged: true, projectRoleInChat: "member" }),
expect.objectContaining({ userId: "user_responsible", roleInChat: "member", isProjectManaged: true, projectRoleInChat: "member" }),
])
);
expect(mocks.tx.group.findMany).toHaveBeenCalledWith(expect.objectContaining({ where: { tenantId: "tenant_1", id: { in: ["group_1"] } } }));
expect(mocks.tx.tenantUser.findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: expect.objectContaining({
tenantId: "tenant_1",
status: 2,
user: { active: true, pendingDeletion: false, pseudonymized: false },
}),
})
);
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledTimes(4);
expect(mocks.writeSystemMessage).toHaveBeenCalledTimes(5);
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
TX,
expect.objectContaining({
kind: "project_created",
metadata: expect.objectContaining({ projectId: "project_1", projectName: "Wärmepumpe Müller" }),
})
);
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
TX,
expect.objectContaining({ kind: "member_added", metadata: expect.objectContaining({ memberUserId: "user_pl" }) })
);
expect(mocks.publishRealtimeWakeup).toHaveBeenCalledTimes(9);
const projectLeaderEvent = mocks.tx.teamChatEvent.create.mock.calls.find((call) => call[0].data.entityId === "user_pl");
expect(projectLeaderEvent?.[0].data.data).toEqual({
userId: "user_pl",
roleInChat: "admin",
joinedAt: NOW.toISOString(),
});
expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledOnce();
expect(mocks.logActivity).toHaveBeenCalledOnce();
const projectLock = mocks.tx.$executeRaw.mock.calls.find((call) => call.includes("project-channel:tenant_1:project_1"));
expect(String(projectLock?.[0])).toContain("pg_advisory_xact_lock");
});
it("is a no-op when the channel and project-derived membership already match", async () => {
mocks.tx.teamChatMember.findMany.mockResolvedValue([projectMember({ userId: "user_pl", roleInChat: "admin" })]);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
actorUserId: "user_actor",
requestId: "request_noop",
});
expect(result).toMatchObject({ created: false, reactivated: false, changed: false });
expect(mocks.tx.teamChat.create).not.toHaveBeenCalled();
expect(mocks.tx.teamChatMember.create).not.toHaveBeenCalled();
expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled();
expect(mocks.tx.teamChatEvent.create).not.toHaveBeenCalled();
expect(mocks.writeSystemMessage).not.toHaveBeenCalled();
expect(mocks.publishRealtimeWakeup).not.toHaveBeenCalled();
expect(mocks.publishAuditEventViaOutbox).not.toHaveBeenCalled();
expect(mocks.logActivity).not.toHaveBeenCalled();
});
it("revokes only pure project write access and leaves manual guests writable", async () => {
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({ userId: "user_pl", roleInChat: "admin" }),
projectMember({ id: "member_removed", userId: "user_removed" }),
projectMember({ id: "member_overlap", userId: "user_overlap", isManualMember: true }),
projectMember({ id: "member_guest", userId: "user_manual_guest", isProjectManaged: false, isManualMember: true }),
]);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
actorUserId: "user_actor",
requestId: "request_remove",
});
expect(result.projectSourceRemovedUserIds).toEqual(["user_overlap", "user_removed"]);
expect(result.writeRevokedUserIds).toEqual(["user_removed"]);
const removedUpdate = memberUpdateFor("user_removed");
expect(removedUpdate?.data).toEqual({
isProjectManaged: false,
projectRoleInChat: null,
roleInChat: "member",
writeRevokedAt: NOW,
leftAt: null,
});
const overlapUpdate = memberUpdateFor("user_overlap");
expect(overlapUpdate?.data).toEqual({
isProjectManaged: false,
projectRoleInChat: null,
roleInChat: "member",
writeRevokedAt: null,
leftAt: null,
});
expect(memberUpdateFor("user_manual_guest")).toBeUndefined();
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledOnce();
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith(
expect.objectContaining({
data: expect.objectContaining({
type: "member_removed",
entityId: "user_removed",
data: { userId: "user_removed", leftAt: NOW.toISOString() },
}),
})
);
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
TX,
expect.objectContaining({
kind: "member_write_access_changed",
metadata: expect.objectContaining({ memberUserId: "user_removed", canWrite: false }),
})
);
expect(mocks.publishRealtimeWakeup).toHaveBeenCalledTimes(2);
});
it("restores a former project member without creating a duplicate membership", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({
...BASE_PROJECT,
projektleiterId: null,
});
mocks.tx.projektMitglied.findMany.mockResolvedValue([{ userId: "user_readded", groupId: null }]);
mocks.tx.tenantUser.findMany.mockResolvedValue([tenantUser("user_readded")]);
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({
id: "member_readded",
userId: "user_readded",
isProjectManaged: false,
isManualMember: false,
writeRevokedAt: new Date("2026-07-15T08:00:00.000Z"),
}),
]);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
actorUserId: "user_actor",
requestId: "request_readd",
});
expect(result.projectSourceAddedUserIds).toEqual(["user_readded"]);
expect(result.writeRestoredUserIds).toEqual(["user_readded"]);
expect(mocks.tx.teamChatMember.create).not.toHaveBeenCalled();
expect(memberUpdateFor("user_readded")?.data).toEqual({
isProjectManaged: true,
projectRoleInChat: "member",
roleInChat: "member",
writeRevokedAt: null,
leftAt: null,
joinedAt: NOW,
joinedViaUserId: "user_actor",
});
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith(
expect.objectContaining({ data: expect.objectContaining({ type: "member_added", entityId: "user_readded" }) })
);
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
TX,
expect.objectContaining({
kind: "member_write_access_changed",
metadata: expect.objectContaining({ memberUserId: "user_readded", canWrite: true }),
})
);
});
it("reactivates the existing archived project channel instead of creating a duplicate", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
mocks.tx.teamChat.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce(CHANNEL);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_reactivate",
reactivateArchived: true,
});
expect(result).toMatchObject({ chatId: CHANNEL.id, created: false, reactivated: true, changed: true });
expect(mocks.tx.teamChat.create).not.toHaveBeenCalled();
expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({
where: {
id: CHANNEL.id,
tenantId: "tenant_1",
projektId: "project_1",
kind: "project",
archivedAt: { not: null },
},
data: {
archivedAt: null,
archivedReason: null,
name: "Wärmepumpe Müller",
description: "Projekt-Chat für Wärmepumpe Müller, P-2026-0042",
isDemoData: false,
},
});
});
it("does not reopen an archived project channel during an ordinary member sync", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
mocks.tx.teamChat.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce(CHANNEL);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_sync_archived",
});
expect(result).toMatchObject({ chatId: CHANNEL.id, created: false, reactivated: false, changed: false });
expect(mocks.tx.teamChat.create).not.toHaveBeenCalled();
expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled();
expect(mocks.tx.projektMitglied.findMany).not.toHaveBeenCalled();
expect(mocks.tx.teamChatMember.findMany).not.toHaveBeenCalled();
expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled();
});
it("preserves a manually granted admin role when that user also becomes project-managed", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
mocks.tx.projektMitglied.findMany.mockResolvedValue([{ userId: "user_manual_admin", groupId: null }]);
mocks.tx.tenantUser.findMany.mockResolvedValue([tenantUser("user_manual_admin")]);
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({
id: "member_manual_admin",
userId: "user_manual_admin",
roleInChat: "admin",
isProjectManaged: false,
isManualMember: true,
}),
]);
await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_manual_admin",
});
expect(memberUpdateFor("user_manual_admin")?.data).toEqual({
isProjectManaged: true,
projectRoleInChat: "member",
roleInChat: "admin",
writeRevokedAt: null,
leftAt: null,
});
});
it("promotes a manual member while they are project lead and falls back to manual member after project removal", async () => {
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({
id: "member_overlap",
userId: "user_pl",
roleInChat: "member",
isProjectManaged: false,
isManualMember: true,
manualRoleInChat: "member",
projectRoleInChat: null,
}),
]);
await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_promote_project_lead",
});
expect(memberUpdateFor("user_pl")?.data).toEqual({
isProjectManaged: true,
projectRoleInChat: "admin",
roleInChat: "admin",
writeRevokedAt: null,
leftAt: null,
});
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
TX,
expect.objectContaining({ kind: "project_leader_changed", metadata: expect.objectContaining({ newLeaderUserId: "user_pl" }) })
);
vi.clearAllMocks();
mocks.tx.$executeRaw.mockResolvedValue(1);
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
mocks.tx.projektMitglied.findMany.mockResolvedValue([]);
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
mocks.tx.teamChat.findFirst.mockResolvedValue(CHANNEL);
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({
id: "member_overlap",
userId: "user_pl",
roleInChat: "admin",
isManualMember: true,
manualRoleInChat: "member",
projectRoleInChat: "admin",
}),
]);
mocks.tx.teamChatMember.updateMany.mockResolvedValue({ count: 1 });
mocks.publishAuditEventViaOutbox.mockResolvedValue(undefined);
mocks.logActivity.mockResolvedValue({ id: "activity_2" });
const removed = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_remove_project_lead",
});
expect(removed.writeRevokedUserIds).toEqual([]);
expect(memberUpdateFor("user_pl")?.data).toEqual({
isProjectManaged: false,
projectRoleInChat: null,
roleInChat: "member",
writeRevokedAt: null,
leftAt: null,
});
});
it("keeps a manual admin effective after losing the project-lead source", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({
id: "member_manual_admin",
userId: "user_old_pl",
roleInChat: "admin",
isManualMember: true,
manualRoleInChat: "admin",
projectRoleInChat: "admin",
}),
]);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_manual_admin_fallback",
});
expect(result.writeRevokedUserIds).toEqual([]);
expect(memberUpdateFor("user_old_pl")?.data).toEqual({
isProjectManaged: false,
projectRoleInChat: null,
roleInChat: "admin",
writeRevokedAt: null,
leftAt: null,
});
});
it("demotes and write-revokes a pure former project lead without retaining admin", async () => {
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
mocks.tx.teamChatMember.findMany.mockResolvedValue([
projectMember({
id: "member_old_pl",
userId: "user_old_pl",
roleInChat: "admin",
projectRoleInChat: "admin",
}),
]);
const result = await ensureAndSyncProjectChannelWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
requestId: "request_revoke_old_project_lead",
});
expect(result.writeRevokedUserIds).toEqual(["user_old_pl"]);
expect(memberUpdateFor("user_old_pl")?.data).toEqual({
isProjectManaged: false,
projectRoleInChat: null,
roleInChat: "member",
writeRevokedAt: NOW,
leftAt: null,
});
});
it("archives an active project channel with a durable event and audit trail", async () => {
const result = await archiveProjectChannelIfEnabledWithTx(TX, {
tenantId: "tenant_1",
projectId: "project_1",
actorUserId: null,
requestId: "request_archive",
reason: "project_completed",
archivedAt: NOW,
});
expect(result).toEqual({ chatId: CHANNEL.id, archived: true });
expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({
where: { tenantId: "tenant_1", id: CHANNEL.id, projektId: "project_1", kind: "project", archivedAt: null },
data: { archivedAt: NOW, archivedReason: "project_completed" },
});
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith({
data: {
tenantId: "tenant_1",
chatId: CHANNEL.id,
type: "channel_archived",
actorUserId: null,
entityId: "project_1",
requestId: "request_archive",
data: { archivedAt: NOW.toISOString(), reason: "project_completed" },
},
select: {
sequence: true,
occurredAt: true,
tenantId: true,
chatId: true,
type: true,
actorUserId: true,
entityId: true,
requestId: true,
data: true,
},
});
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
TX,
expect.objectContaining({ kind: "channel_archived", metadata: { projectId: "project_1", reason: "project_completed" } })
);
expect(mocks.publishRealtimeWakeup).toHaveBeenCalledTimes(2);
expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledOnce();
expect(mocks.logActivity).toHaveBeenCalledOnce();
});
});
function projectMember(overrides: Record<string, unknown> = {}) {
const merged = {
id: "member_project",
userId: "user_project",
roleInChat: "member",
isProjectManaged: true,
isManualMember: false,
isGroupManaged: false,
manualRoleInChat: null,
projectRoleInChat: "member",
writeRevokedAt: null,
leftAt: null,
...overrides,
};
return {
...merged,
manualRoleInChat:
Object.prototype.hasOwnProperty.call(overrides, "manualRoleInChat")
? merged.manualRoleInChat
: merged.isManualMember
? merged.roleInChat
: null,
projectRoleInChat:
Object.prototype.hasOwnProperty.call(overrides, "projectRoleInChat")
? merged.projectRoleInChat
: merged.isProjectManaged
? merged.roleInChat
: null,
};
}
function memberUpdateFor(userId: string): { where: Record<string, unknown>; data: Record<string, unknown> } | undefined {
const call = mocks.tx.teamChatMember.updateMany.mock.calls.find((candidate) => candidate[0].where.userId === userId);
return call?.[0];
}
function tenantUser(userId: string) {
return {
userId,
user: {
firstName: userId,
lastName: null,
email: `${userId}@example.test`,
},
};
}
function realtimeSystemEvent(input: { tenantId: string; chatId: string; requestId: string }) {
return {
event: "chat.message.created",
cursor: `${CHANNEL.eventStreamId}:99`,
requestId: input.requestId,
tenantId: input.tenantId,
chatId: input.chatId,
occurredAt: NOW.toISOString(),
data: {},
};
}