637 lines
23 KiB
TypeScript
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: {},
|
|
};
|
|
}
|