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 }) => ({ ...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 = {}) { 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; data: Record } | 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: {}, }; }