import { beforeEach, describe, expect, it, vi } from "vitest"; import { CHAT_PERMISSIONS } from "./permissions.js"; const mocks = vi.hoisted(() => ({ getWriteDbClient: vi.fn(), runWithRlsContext: vi.fn(), publishAuditEventViaOutbox: vi.fn(), publishChatPersistentRealtimeWakeup: vi.fn(), writeChatSystemMessageWithTx: vi.fn(), tenantHasChatModuleWithPermissionsTx: vi.fn(), logActivity: vi.fn(), nextEventSequence: 1n, activeTargetUserIds: [] as string[], currentPermissions: [] as string[], client: { $transaction: vi.fn(), }, tx: { $queryRaw: vi.fn(), $executeRaw: vi.fn(), group: { findMany: vi.fn() }, tenantUser: { findMany: vi.fn() }, teamChat: { create: vi.fn(), findFirst: vi.fn(), updateMany: vi.fn() }, teamChatGroupSource: { createMany: vi.fn() }, teamChatMember: { create: vi.fn(), createMany: vi.fn(), upsert: vi.fn(), updateMany: vi.fn(), }, teamChatMessage: { findMany: vi.fn() }, teamChatEvent: { create: vi.fn(), findMany: vi.fn() }, }, })); vi.mock("@hivegrid/activity", () => ({ logActivity: (...args: unknown[]) => mocks.logActivity(...args), })); vi.mock("@hivegrid/db/audit-events.server", () => ({ publishAuditEventViaOutbox: (...args: unknown[]) => mocks.publishAuditEventViaOutbox(...args), })); vi.mock("@hivegrid/db/client.server", () => ({ getWriteDbClient: () => mocks.getWriteDbClient(), })); vi.mock("@hivegrid/db/rls-context.server", () => ({ runWithRlsContext: (context: unknown, callback: () => unknown) => mocks.runWithRlsContext(context, callback), })); vi.mock("./realtime-wakeup.server.js", () => ({ publishChatPersistentRealtimeWakeup: (...args: unknown[]) => mocks.publishChatPersistentRealtimeWakeup(...args), })); vi.mock("./system-message.server.js", () => ({ writeChatSystemMessageWithTx: (...args: unknown[]) => mocks.writeChatSystemMessageWithTx(...args), })); vi.mock("./module-access.server.js", () => ({ tenantHasChatModuleWithPermissionsTx: (...args: unknown[]) => mocks.tenantHasChatModuleWithPermissionsTx(...args), })); import { archiveChatChannel, archiveGroupChat, canonicalChatDmPairKey, createGroupChat, getOrCreateDirectMessage, joinPublicGroupChat, leaveGroupChat, removeChatChannelMember, removeGroupChatMember, setChatChannelMember, setGroupChatPrivacy, setGroupChatMember, } from "./lifecycle.server.js"; const NOW = new Date("2026-07-16T08:00:00.000Z"); const createContext = { tenantId: "tenant_1", userId: "user_1", permissions: [CHAT_PERMISSIONS.createChannel], } as const; const memberContext = { tenantId: "tenant_1", userId: "user_1", permissions: [CHAT_PERMISSIONS.readOwnChannels], } as const; const dmContext = { tenantId: "tenant_1", userId: "user_z", permissions: [CHAT_PERMISSIONS.createDm], } as const; type GroupMember = { userId: string; roleInChat: "admin" | "member"; notificationPref: "all_messages" | "mentions_only" | "muted"; joinedAt: Date; isProjectManaged: boolean; isManualMember: boolean; isGroupManaged: boolean; manualRoleInChat: "admin" | "member" | null; projectRoleInChat: "admin" | "member" | null; groupSyncOptOutAt: Date | null; writeRevokedAt: Date | null; leftAt: Date | null; }; function member( userId: string, roleInChat: "admin" | "member", leftAt: Date | null = null, overrides: Partial = {} ): GroupMember { return { userId, roleInChat, notificationPref: "all_messages", joinedAt: NOW, isProjectManaged: false, isManualMember: true, isGroupManaged: false, manualRoleInChat: roleInChat, projectRoleInChat: null, groupSyncOptOutAt: null, writeRevokedAt: null, leftAt, ...overrides, }; } function groupChannel(overrides: Record = {}) { return { id: "chat_group", kind: "group", name: "Montage", description: null, projektId: null, isPrivate: false, archivedAt: null, archivedReason: null, notificationDefault: "all_messages", eventStreamId: "stream_group", dmPairKey: null, members: [member("user_1", "admin")], ...overrides, }; } function projectChannel(overrides: Record = {}) { return groupChannel({ id: "chat_project", kind: "project", projektId: "project_1", isPrivate: true, eventStreamId: "stream_project", members: [ member("user_1", "admin", null, { isManualMember: false, manualRoleInChat: null, isProjectManaged: true, projectRoleInChat: "admin" }), ], ...overrides, }); } function directMessageChannel(leftUserId = "user_a", rightUserId = "user_z") { return { id: "chat_dm", kind: "dm", name: null, description: null, projektId: null, isPrivate: true, archivedAt: null, archivedReason: null, notificationDefault: "all_messages", eventStreamId: "stream_dm", dmPairKey: canonicalChatDmPairKey(leftUserId, rightUserId), members: [member(leftUserId, "member"), member(rightUserId, "member")].sort((left, right) => left.userId.localeCompare(right.userId)), }; } describe("chat lifecycle repository", () => { beforeEach(() => { vi.clearAllMocks(); mocks.nextEventSequence = 1n; mocks.tenantHasChatModuleWithPermissionsTx.mockResolvedValue(true); mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_2"); mocks.currentPermissions.splice( 0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.createChannel, CHAT_PERMISSIONS.createDm, CHAT_PERMISSIONS.admin ); mocks.getWriteDbClient.mockReturnValue(mocks.client); mocks.runWithRlsContext.mockImplementation((_context, callback: () => unknown) => callback()); mocks.client.$transaction.mockImplementation((callback: (tx: typeof mocks.tx) => unknown) => callback(mocks.tx)); mocks.tx.$queryRaw.mockImplementation(async (query: TemplateStringsArray, ...values: unknown[]) => { if (String(query).includes("target_tenant_user")) { const userId = values[1]; return typeof userId === "string" && mocks.activeTargetUserIds.includes(userId) ? [{ userId }] : []; } if (String(query).includes('permission_row."name"')) { return mocks.currentPermissions.map((name) => ({ name })); } return [{ id: "tenant_user_1" }]; }); mocks.tx.$executeRaw.mockResolvedValue(1); mocks.tx.teamChat.create.mockResolvedValue({ id: "chat_new", eventStreamId: "stream_new" }); mocks.tx.teamChat.updateMany.mockResolvedValue({ count: 1 }); mocks.tx.group.findMany.mockResolvedValue([]); mocks.tx.tenantUser.findMany.mockImplementation(async ({ where }: { where: { userId?: { in?: string[] } } }) => (where.userId?.in ?? []).map((userId) => ({ userId, user: { firstName: userId, lastName: null, email: `${userId}@example.test` }, })) ); mocks.tx.teamChatGroupSource.createMany.mockResolvedValue({ count: 0 }); mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel()); mocks.tx.teamChatMember.create.mockResolvedValue({ id: "member_1" }); mocks.tx.teamChatMember.createMany.mockResolvedValue({ count: 2 }); mocks.tx.teamChatMember.upsert.mockResolvedValue({ id: "member_1" }); mocks.tx.teamChatMember.updateMany.mockResolvedValue({ count: 1 }); mocks.tx.teamChatMessage.findMany.mockResolvedValue([]); mocks.tx.teamChatEvent.create.mockImplementation(async ({ data }: { data: Record }) => ({ sequence: mocks.nextEventSequence++, occurredAt: NOW, tenantId: data.tenantId, chatId: data.chatId, type: data.type, actorUserId: data.actorUserId, entityId: data.entityId, requestId: data.requestId, data: data.data, })); mocks.tx.teamChatEvent.findMany.mockResolvedValue([]); mocks.publishChatPersistentRealtimeWakeup.mockResolvedValue({ id: "outbox_1" }); mocks.writeChatSystemMessageWithTx.mockImplementation(async (_tx: unknown, input: Record) => ({ replayed: false, event: { event: "chat.message.created", cursor: "stream_new:99", ...input }, })); mocks.publishAuditEventViaOutbox.mockResolvedValue(undefined); mocks.logActivity.mockResolvedValue({ id: "activity_1" }); }); it.each([false, true])("creates a %s group with the creator as tenant-scoped admin", async (isPrivate) => { const result = await createGroupChat({ ...createContext, requestId: `request_group_${isPrivate}`, name: " Einsatzleitung ", description: " Schichtübergabe ", isPrivate, notificationDefault: "mentions_only", }); expect(result).toEqual({ chatId: "chat_new" }); expect(mocks.runWithRlsContext).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1" }, expect.any(Function)); expect(mocks.tx.teamChat.create).toHaveBeenCalledWith( expect.objectContaining({ data: expect.objectContaining({ tenantId: "tenant_1", createdByUserId: "user_1", kind: "group", name: "Einsatzleitung", description: "Schichtübergabe", isPrivate, notificationDefault: "mentions_only", }), }) ); expect(mocks.tx.teamChatMember.create).toHaveBeenCalledWith( expect.objectContaining({ data: expect.objectContaining({ tenantId: "tenant_1", chatId: "chat_new", userId: "user_1", roleInChat: "admin", isManualMember: true, isProjectManaged: false, manualRoleInChat: "admin", projectRoleInChat: null, writeRevokedAt: null, }), }) ); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledOnce(); expect(mocks.logActivity).toHaveBeenCalledOnce(); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledWith( mocks.tx, expect.objectContaining({ kind: "group_created", metadata: expect.objectContaining({ channelName: "Einsatzleitung" }) }) ); expect(mocks.publishChatPersistentRealtimeWakeup).toHaveBeenCalledTimes(2); }); it("replays one group creation request and rejects payload drift under the same request id", async () => { const createInput = { ...createContext, requestId: "request_idempotent_group", name: "Einsatzleitung", description: "Schichtübergabe", isPrivate: true, notificationDefault: "mentions_only" as const, }; await expect(createGroupChat(createInput)).resolves.toEqual({ chatId: "chat_new" }); const creationCall = mocks.writeChatSystemMessageWithTx.mock.calls.find((call) => call[1]?.kind === "group_created"); expect(creationCall?.[1]).toMatchObject({ systemEventKey: expect.stringMatching(/^group:create:/), metadata: { channelName: "Einsatzleitung", creationFingerprint: expect.stringMatching(/^[a-f0-9]{64}$/) }, }); const creationFingerprint = creationCall?.[1]?.metadata.creationFingerprint as string; mocks.tx.teamChatMessage.findMany.mockResolvedValue([ { chatId: "chat_new", systemEventMetadata: { channelName: "Einsatzleitung", creationFingerprint } }, ]); await expect(createGroupChat(createInput)).resolves.toEqual({ chatId: "chat_new" }); expect(mocks.tx.teamChat.create).toHaveBeenCalledOnce(); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledOnce(); await expect(createGroupChat({ ...createInput, name: "Anderer Name" })).rejects.toMatchObject({ code: "foundation.idempotency_conflict", }); expect(mocks.tx.teamChat.create).toHaveBeenCalledOnce(); }); it("deduplicates and atomically adds active initial group members with events and audit", async () => { mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_2", "user_3"); await createGroupChat({ ...createContext, requestId: "request_initial_members", name: "Disposition", isPrivate: true, initialMemberUserIds: ["user_3", " user_2 ", "user_1", "user_2"], }); const targetUserLocks = mocks.tx.$queryRaw.mock.calls.filter((call) => String(call[0]).includes("target_tenant_user")); expect(targetUserLocks).toHaveLength(2); expect(String(targetUserLocks[0]?.[0])).toContain("FOR SHARE OF target_tenant_user, target_user"); expect(targetUserLocks.flat()).toContain("tenant_1"); expect(targetUserLocks.flat()).toContain("user_2"); expect(targetUserLocks.flat()).toContain("user_3"); expect(mocks.tx.teamChatMember.createMany).toHaveBeenCalledWith({ data: [ expect.objectContaining({ tenantId: "tenant_1", userId: "user_2", roleInChat: "member", isManualMember: true, isProjectManaged: false, manualRoleInChat: "member", projectRoleInChat: null, writeRevokedAt: null, }), expect.objectContaining({ tenantId: "tenant_1", userId: "user_3", roleInChat: "member", isManualMember: true, isProjectManaged: false, manualRoleInChat: "member", projectRoleInChat: null, writeRevokedAt: null, }), ], }); expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledTimes(3); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledTimes(3); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledTimes(3); expect(mocks.publishChatPersistentRealtimeWakeup).toHaveBeenCalledTimes(6); }); it("rejects an unavailable initial group member before creating the channel", async () => { mocks.activeTargetUserIds.length = 0; await expect( createGroupChat({ ...createContext, requestId: "request_unavailable_member", name: "Disposition", isPrivate: false, initialMemberUserIds: ["user_external"], }) ).rejects.toMatchObject({ code: "foundation.not_found" }); expect(mocks.tx.teamChat.create).not.toHaveBeenCalled(); }); it("expands permission groups and keeps direct and auto-sync provenance independent", async () => { mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_2", "user_3"); mocks.tx.group.findMany.mockResolvedValueOnce([ { id: "group_1", users: [{ userId: "user_1" }, { userId: "user_2" }, { userId: "user_3" }] }, ]); mocks.tx.teamChatGroupSource.createMany.mockResolvedValueOnce({ count: 1 }); mocks.tx.teamChatMember.createMany.mockResolvedValueOnce({ count: 2 }); await createGroupChat({ ...createContext, requestId: "request_group_source", name: "Team Süd", isPrivate: false, initialMemberUserIds: ["user_3"], initialGroupIds: ["group_1"], syncGroupMembership: true, }); expect(mocks.tx.teamChatGroupSource.createMany).toHaveBeenCalledWith({ data: [{ tenantId: "tenant_1", chatId: "chat_new", groupId: "group_1", syncEnabled: true }], }); expect(mocks.tx.teamChatMember.create).toHaveBeenCalledWith( expect.objectContaining({ data: expect.objectContaining({ userId: "user_1", isManualMember: true, isGroupManaged: true }) }) ); expect(mocks.tx.teamChatMember.createMany).toHaveBeenCalledWith({ data: [ expect.objectContaining({ userId: "user_2", isManualMember: false, isGroupManaged: true }), expect.objectContaining({ userId: "user_3", isManualMember: true, isGroupManaged: true }), ], }); expect(mocks.publishAuditEventViaOutbox).toHaveBeenNthCalledWith( 1, expect.objectContaining({}), expect.objectContaining({ metadata: expect.objectContaining({ initialGroupCount: 1, initialMemberCount: 2, syncGroupMembership: true }), }) ); }); it("uses a selected group as a one-time manual snapshot when auto-sync is off", async () => { mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_2"); mocks.tx.group.findMany.mockResolvedValueOnce([{ id: "group_1", users: [{ userId: "user_2" }] }]); mocks.tx.teamChatGroupSource.createMany.mockResolvedValueOnce({ count: 1 }); mocks.tx.teamChatMember.createMany.mockResolvedValueOnce({ count: 1 }); await createGroupChat({ ...createContext, requestId: "request_group_snapshot", name: "Lehrlinge", isPrivate: true, initialGroupIds: ["group_1"], syncGroupMembership: false, }); expect(mocks.tx.teamChatGroupSource.createMany).toHaveBeenCalledWith({ data: [{ tenantId: "tenant_1", chatId: "chat_new", groupId: "group_1", syncEnabled: false }], }); expect(mocks.tx.teamChatMember.createMany).toHaveBeenCalledWith({ data: [expect.objectContaining({ userId: "user_2", isManualMember: true, isGroupManaged: false })], }); }); it("rejects auto-sync without a selected permission group", async () => { await expect( createGroupChat({ ...createContext, requestId: "request_group_sync_without_source", name: "Ungültig", isPrivate: false, syncGroupMembership: true, }) ).rejects.toMatchObject({ code: "chat.invalid_input" }); expect(mocks.client.$transaction).not.toHaveBeenCalled(); }); it("checks the exact group-create permission before writing", async () => { mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); await expect( createGroupChat({ ...createContext, permissions: [CHAT_PERMISSIONS.readOwnChannels], requestId: "request_denied", name: "Nicht erlaubt", isPrivate: false, }) ).rejects.toMatchObject({ code: "foundation.not_found" }); expect(mocks.tx.teamChat.create).not.toHaveBeenCalled(); }); it("reactivates a public group membership but does not expose a private group", async () => { const optedOutAt = new Date("2026-07-15T08:00:00.000Z"); mocks.tx.teamChat.findFirst.mockResolvedValueOnce( groupChannel({ members: [ member("user_1", "member", optedOutAt, { isManualMember: false, isGroupManaged: true, manualRoleInChat: null, groupSyncOptOutAt: optedOutAt, }), ], }) ); const joined = await joinPublicGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_join" }); expect(joined).toMatchObject({ changed: true, memberUserId: "user_1", roleInChat: "member" }); expect(mocks.tx.teamChatMember.upsert).toHaveBeenCalledWith( expect.objectContaining({ create: expect.objectContaining({ tenantId: "tenant_1", chatId: "chat_group", userId: "user_1" }), update: expect.objectContaining({ roleInChat: "member", groupSyncOptOutAt: null, leftAt: null }), }) ); mocks.tx.teamChat.findFirst.mockResolvedValueOnce(groupChannel({ isPrivate: true })); await expect(joinPublicGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_private" })).rejects.toMatchObject({ code: "foundation.not_found", }); expect(mocks.tx.teamChatMember.upsert).toHaveBeenCalledTimes(1); }); it("treats joining an already active manual public-group membership as an idempotent no-op", async () => { mocks.tx.teamChat.findFirst.mockResolvedValueOnce(groupChannel({ members: [member("user_1", "member")] })); await expect(joinPublicGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_join_replay" })).resolves.toEqual({ chatId: "chat_group", memberUserId: "user_1", roleInChat: "member", changed: false, }); expect(mocks.tx.teamChatMember.upsert).not.toHaveBeenCalled(); expect(mocks.tx.teamChatEvent.create).not.toHaveBeenCalled(); expect(mocks.writeChatSystemMessageWithTx).not.toHaveBeenCalled(); expect(mocks.publishChatPersistentRealtimeWakeup).not.toHaveBeenCalled(); }); it("lets a group admin add or promote only an active user of the same tenant", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel({ members: [member("user_1", "admin"), member("user_2", "member")] })); mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_2"); const result = await setGroupChatMember({ ...memberContext, chatId: "chat_group", memberUserId: "user_2", roleInChat: "admin", requestId: "request_promote", }); expect(result).toMatchObject({ changed: true, memberUserId: "user_2", roleInChat: "admin" }); const targetUserLock = mocks.tx.$queryRaw.mock.calls.find((call) => String(call[0]).includes("target_tenant_user")); expect(String(targetUserLock?.[0])).toContain('target_user."pendingDeletion" = FALSE'); expect(String(targetUserLock?.[0])).toContain('target_user."pseudonymized" = FALSE'); expect(targetUserLock).toContain("tenant_1"); expect(targetUserLock).toContain("user_2"); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", chatId: "chat_group", userId: "user_2", leftAt: null }, data: { roleInChat: "admin", isManualMember: true, manualRoleInChat: "admin", groupSyncOptOutAt: null, writeRevokedAt: null, leftAt: null, }, }); }); it("denies member management after chat.admin revocation despite a stale route permission snapshot", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel({ members: [member("user_1", "member"), member("user_2", "member")] })); mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); await expect( removeGroupChatMember({ ...memberContext, permissions: [CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.admin], chatId: "chat_group", memberUserId: "user_2", requestId: "request_remove", }) ).rejects.toMatchObject({ code: "foundation.not_found" }); expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled(); }); it("uses a freshly loaded chat.admin grant for a non-admin group member", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel({ members: [member("user_1", "member"), member("user_2", "member")] })); await expect( setGroupChatMember({ ...memberContext, chatId: "chat_group", memberUserId: "user_2", roleInChat: "admin", requestId: "request_current_admin", }) ).resolves.toMatchObject({ changed: true, memberUserId: "user_2", roleInChat: "admin" }); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledOnce(); }); it.each([ ["demote", () => setGroupChatMember({ ...memberContext, chatId: "chat_group", memberUserId: "user_1", roleInChat: "member", requestId: "request_demote" })], ["remove", () => removeGroupChatMember({ ...memberContext, chatId: "chat_group", memberUserId: "user_1", requestId: "request_remove" })], ["leave", () => leaveGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_leave" })], ])("prevents the last admin from attempting to %s", async (_action, operation) => { mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel({ members: [member("user_1", "admin")] })); mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_1"); await expect(operation()).rejects.toMatchObject({ code: "chat.invalid_input" }); expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled(); }); it("removes a group member when an admin remains", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel({ members: [member("user_1", "admin"), member("user_2", "member")] })); const result = await removeGroupChatMember({ ...memberContext, chatId: "chat_group", memberUserId: "user_2", requestId: "request_remove_member", }); expect(result).toMatchObject({ changed: true, memberUserId: "user_2" }); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", chatId: "chat_group", userId: "user_2", leftAt: null }, data: { isManualMember: false, manualRoleInChat: null, roleInChat: "member", leftAt: expect.any(Date), }, }); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledWith( mocks.tx, expect.objectContaining({ kind: "member_removed", systemEventKey: expect.stringMatching(/^group:[a-f0-9]{24}:member:[a-f0-9]{24}:removed:[a-f0-9]{24}$/), metadata: expect.objectContaining({ memberUserId: "user_2", memberName: "user_2" }), }) ); expect(mocks.publishChatPersistentRealtimeWakeup).toHaveBeenCalledTimes(2); }); it("falls back from a removed manual admin grant to a remaining group member grant", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue( groupChannel({ members: [ member("user_1", "admin"), member("user_2", "admin", null, { isGroupManaged: true, manualRoleInChat: "admin", }), ], }) ); const result = await removeGroupChatMember({ ...memberContext, chatId: "chat_group", memberUserId: "user_2", requestId: "request_remove_manual_admin_source", }); expect(result).toEqual({ chatId: "chat_group", memberUserId: "user_2", roleInChat: "member", changed: true }); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", chatId: "chat_group", userId: "user_2", leftAt: null }, data: { isManualMember: false, manualRoleInChat: null, roleInChat: "member", writeRevokedAt: null, leftAt: null, }, }); expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith( expect.objectContaining({ data: expect.objectContaining({ type: "member_added", entityId: "user_2" }) }) ); }); it("persists an opt-out when a group-managed member leaves", async () => { mocks.tx.teamChat.findFirst.mockResolvedValueOnce( groupChannel({ members: [ member("user_1", "member", null, { isManualMember: false, isGroupManaged: true, manualRoleInChat: null }), member("user_2", "admin"), ], }) ); await expect(leaveGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_leave_managed" })).resolves.toMatchObject({ changed: true, memberUserId: "user_1", }); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", chatId: "chat_group", userId: "user_1", leftAt: null }, data: { isManualMember: false, manualRoleInChat: null, roleInChat: "member", groupSyncOptOutAt: expect.any(Date), leftAt: expect.any(Date), }, }); expect(mocks.tx.$executeRaw.mock.calls[0]?.[1]).toBe("chat-membership:tenant_1:chat_group"); }); it("manages only the manual source of a project guest and recomputes the effective role", async () => { mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); mocks.tx.teamChat.findFirst .mockResolvedValueOnce(projectChannel({ members: [ member("user_1", "admin", null, { isManualMember: false, manualRoleInChat: null, isProjectManaged: true, projectRoleInChat: "admin" }), member("user_2", "member", null, { isManualMember: false, manualRoleInChat: null, isProjectManaged: true, projectRoleInChat: "member" }), ], })) .mockResolvedValueOnce(projectChannel({ members: [ member("user_1", "admin", null, { isManualMember: false, manualRoleInChat: null, isProjectManaged: true, projectRoleInChat: "admin" }), member("user_2", "admin", null, { isManualMember: true, manualRoleInChat: "admin", isProjectManaged: true, projectRoleInChat: "member" }), ], })); await expect( setChatChannelMember({ ...memberContext, chatId: "chat_project", memberUserId: "user_2", roleInChat: "admin", requestId: "project_guest_promote" }) ).resolves.toMatchObject({ roleInChat: "admin", changed: true }); await expect( removeChatChannelMember({ ...memberContext, chatId: "chat_project", memberUserId: "user_2", requestId: "project_guest_remove" }) ).resolves.toEqual({ chatId: "chat_project", memberUserId: "user_2", roleInChat: "member", changed: true }); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenNthCalledWith(1, { where: { tenantId: "tenant_1", chatId: "chat_project", userId: "user_2", leftAt: null }, data: expect.objectContaining({ isManualMember: true, manualRoleInChat: "admin", roleInChat: "admin" }), }); expect(mocks.tx.teamChatMember.updateMany).toHaveBeenNthCalledWith(2, { where: { tenantId: "tenant_1", chatId: "chat_project", userId: "user_2", leftAt: null }, data: { isManualMember: false, manualRoleInChat: null, roleInChat: "member", writeRevokedAt: null, leftAt: null }, }); expect(mocks.tx.teamChatMember.updateMany.mock.calls.some(([call]) => "isProjectManaged" in call.data || "isGroupManaged" in call.data)).toBe(false); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ action: "chat.project.member_role_changed" })); expect(mocks.logActivity).toHaveBeenCalledWith(expect.objectContaining({ subjectType: "project", subjectId: "project_1" }), { client: mocks.tx }); expect(mocks.tx.$executeRaw.mock.calls[0]?.[1]).toBe("chat-membership:tenant_1:chat_project"); }); it("lets a membership-bound project leader archive the project chat without adding privacy or leave semantics", async () => { mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); mocks.tx.teamChat.findFirst.mockResolvedValueOnce(projectChannel()); await expect( archiveChatChannel({ ...memberContext, chatId: "chat_project", requestId: "project_archive" }) ).resolves.toMatchObject({ chatId: "chat_project", changed: true }); expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", id: "chat_project", kind: "project", archivedAt: null }, data: { archivedAt: expect.any(Date), archivedReason: "manual" }, }); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledWith( mocks.tx, expect.objectContaining({ kind: "channel_archived", systemEventKey: expect.stringMatching(/^project:/) }) ); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ action: "chat.project.archived" })); expect(mocks.logActivity).toHaveBeenCalledWith(expect.objectContaining({ subjectType: "project", subjectId: "project_1" }), { client: mocks.tx }); }); it("lets an active channel admin change group privacy with one durable system wakeup", async () => { mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); mocks.tx.teamChat.findFirst.mockResolvedValueOnce(groupChannel({ isPrivate: false, members: [member("user_1", "admin")] })); const result = await setGroupChatPrivacy({ ...memberContext, chatId: "chat_group", requestId: "request_privacy_private", isPrivate: true, }); expect(result).toEqual({ chatId: "chat_group", isPrivate: true, changed: true }); expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", id: "chat_group", kind: "group", archivedAt: null, isPrivate: false }, data: { isPrivate: true }, }); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledWith( mocks.tx, expect.objectContaining({ kind: "channel_privacy_changed", systemEventKey: expect.stringMatching(/^group:[a-f0-9]{24}:privacy:[a-f0-9]{24}$/), metadata: { privacy: "private" }, }) ); expect(mocks.publishChatPersistentRealtimeWakeup).toHaveBeenCalledOnce(); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "chat.group.privacy_changed", metadata: { isPrivate: true, previousIsPrivate: false }, }) ); expect(mocks.logActivity).toHaveBeenCalledOnce(); expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled(); }); it("replays a privacy request without writes and rejects payload drift", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue(groupChannel({ isPrivate: true })); mocks.tx.teamChatMessage.findMany.mockResolvedValue([{ systemEventMetadata: { privacy: "private" } }]); const request = { ...memberContext, chatId: "chat_group", requestId: "request_privacy_replay", isPrivate: true, } as const; await expect(setGroupChatPrivacy(request)).resolves.toEqual({ chatId: "chat_group", isPrivate: true, changed: false }); expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled(); expect(mocks.writeChatSystemMessageWithTx).not.toHaveBeenCalled(); expect(mocks.publishAuditEventViaOutbox).not.toHaveBeenCalled(); await expect(setGroupChatPrivacy({ ...request, isPrivate: false })).rejects.toMatchObject({ code: "foundation.idempotency_conflict", }); expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled(); }); it("keeps a fresh global chat.admin grant membership-bound in the normal settings path", async () => { mocks.tx.teamChat.findFirst.mockResolvedValueOnce( groupChannel({ isPrivate: false, members: [member("user_2", "admin")] }) ); await expect( setGroupChatPrivacy({ ...memberContext, permissions: [CHAT_PERMISSIONS.readOwnChannels], chatId: "chat_group", requestId: "request_fresh_global_admin", isPrivate: true, }) ).rejects.toMatchObject({ code: "foundation.not_found" }); expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled(); expect(mocks.publishAuditEventViaOutbox).not.toHaveBeenCalled(); }); it("uses fresh chat.admin permissions for group settings and rejects project or DM channels", async () => { mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); mocks.tx.teamChat.findFirst.mockResolvedValueOnce( groupChannel({ members: [member("user_1", "member"), member("user_2", "admin")] }) ); await expect( setGroupChatPrivacy({ ...memberContext, permissions: [CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.admin], chatId: "chat_group", requestId: "request_stale_privacy_admin", isPrivate: true, }) ).rejects.toMatchObject({ code: "foundation.not_found" }); mocks.currentPermissions.push(CHAT_PERMISSIONS.admin); mocks.tx.teamChat.findFirst .mockResolvedValueOnce(groupChannel({ kind: "project", projektId: "project_1" })) .mockResolvedValueOnce(directMessageChannel()); await expect( setGroupChatPrivacy({ ...memberContext, chatId: "chat_project", requestId: "request_project_privacy", isPrivate: false }) ).rejects.toMatchObject({ code: "foundation.not_found" }); await expect( archiveGroupChat({ ...memberContext, chatId: "chat_dm", requestId: "request_dm_archive" }) ).rejects.toMatchObject({ code: "foundation.not_found" }); expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled(); }); it("manually archives a group atomically without altering its last admin", async () => { mocks.currentPermissions.splice(0, mocks.currentPermissions.length, CHAT_PERMISSIONS.readOwnChannels); mocks.tx.teamChat.findFirst.mockResolvedValueOnce(groupChannel({ members: [member("user_1", "admin")] })); const result = await archiveGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_archive_group", }); expect(result).toEqual({ chatId: "chat_group", archivedAtIso: expect.any(String), changed: true }); expect(mocks.writeChatSystemMessageWithTx).toHaveBeenCalledWith( mocks.tx, expect.objectContaining({ kind: "channel_archived", systemEventKey: expect.stringMatching(/^group:[a-f0-9]{24}:archived:[a-f0-9]{24}$/), metadata: { reason: "manual" }, }) ); expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", id: "chat_group", kind: "group", archivedAt: null }, data: { archivedAt: expect.any(Date), archivedReason: "manual" }, }); expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith({ data: { tenantId: "tenant_1", chatId: "chat_group", type: "channel_archived", actorUserId: "user_1", entityId: "chat_group", requestId: "request_archive_group", occurredAt: expect.any(Date), data: { archivedAt: expect.any(String), reason: "manual" }, }, select: expect.any(Object), }); expect(mocks.publishChatPersistentRealtimeWakeup).toHaveBeenCalledTimes(2); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "chat.group.archived", metadata: expect.objectContaining({ reason: "manual" }) }) ); expect(mocks.logActivity).toHaveBeenCalledOnce(); expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled(); expect(mocks.writeChatSystemMessageWithTx.mock.invocationCallOrder[0]).toBeLessThan( mocks.tx.teamChat.updateMany.mock.invocationCallOrder[0] ?? Number.POSITIVE_INFINITY ); }); it("replays the matching manual archive event without duplicate writes", async () => { const archivedAt = new Date("2026-07-16T08:15:00.000Z"); mocks.tx.teamChat.findFirst.mockResolvedValue( groupChannel({ archivedAt, archivedReason: "manual", members: [member("user_1", "admin")] }) ); mocks.tx.teamChatEvent.findMany.mockResolvedValue([ { occurredAt: archivedAt, data: { archivedAt: archivedAt.toISOString(), reason: "manual" } }, ]); await expect( archiveGroupChat({ ...memberContext, chatId: "chat_group", requestId: "request_archive_replay" }) ).resolves.toEqual({ chatId: "chat_group", archivedAtIso: archivedAt.toISOString(), changed: false }); expect(mocks.writeChatSystemMessageWithTx).not.toHaveBeenCalled(); expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled(); expect(mocks.tx.teamChatEvent.create).not.toHaveBeenCalled(); expect(mocks.publishChatPersistentRealtimeWakeup).not.toHaveBeenCalled(); expect(mocks.publishAuditEventViaOutbox).not.toHaveBeenCalled(); }); it("builds an order-independent, collision-safe DM pair key", () => { expect(canonicalChatDmPairKey("user_z", "user_a")).toBe('["user_a","user_z"]'); expect(canonicalChatDmPairKey("user_a", "user_z")).toBe('["user_a","user_z"]'); expect(() => canonicalChatDmPairKey("user_a", "user_a")).toThrow("two different users"); }); it("creates a private DM with exactly the canonical two tenant users", async () => { mocks.tx.teamChat.findFirst.mockResolvedValue(null); mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_a"); const result = await getOrCreateDirectMessage({ ...dmContext, peerUserId: "user_a", requestId: "request_dm", }); expect(result).toEqual({ chatId: "chat_new", dmPairKey: '["user_a","user_z"]', created: true }); expect(mocks.tx.teamChat.create).toHaveBeenCalledWith( expect.objectContaining({ data: expect.objectContaining({ tenantId: "tenant_1", kind: "dm", isPrivate: true, name: null, description: null, projektId: null, dmPairKey: '["user_a","user_z"]', }), }) ); const createMany = mocks.tx.teamChatMember.createMany.mock.calls[0]?.[0]; expect(createMany.data).toHaveLength(2); expect(createMany.data).toEqual([ expect.objectContaining({ tenantId: "tenant_1", chatId: "chat_new", userId: "user_a", roleInChat: "member" }), expect.objectContaining({ tenantId: "tenant_1", chatId: "chat_new", userId: "user_z", roleInChat: "member", isManualMember: true, isProjectManaged: false, writeRevokedAt: null, }), ]); expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledTimes(2); expect(mocks.writeChatSystemMessageWithTx).not.toHaveBeenCalled(); expect(mocks.publishChatPersistentRealtimeWakeup).toHaveBeenCalledTimes(2); expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledOnce(); expect(mocks.logActivity).not.toHaveBeenCalled(); }); it("reuses a valid active DM and rejects a malformed stored pair", async () => { const valid = directMessageChannel(); mocks.activeTargetUserIds.splice(0, mocks.activeTargetUserIds.length, "user_a"); mocks.tx.teamChat.findFirst.mockResolvedValueOnce(valid); await expect(getOrCreateDirectMessage({ ...dmContext, peerUserId: "user_a", requestId: "request_existing" })).resolves.toEqual({ chatId: "chat_dm", dmPairKey: '["user_a","user_z"]', created: false, }); expect(mocks.tx.teamChat.create).not.toHaveBeenCalled(); mocks.tx.teamChat.findFirst.mockResolvedValueOnce({ ...valid, members: [valid.members[0]] }); await expect(getOrCreateDirectMessage({ ...dmContext, peerUserId: "user_a", requestId: "request_broken" })).rejects.toMatchObject({ code: "chat.integrity_failure", }); }); it("fails closed before any DM mutation when the peer is not an active tenant member", async () => { mocks.activeTargetUserIds.length = 0; await expect(getOrCreateDirectMessage({ ...dmContext, peerUserId: "user_external", requestId: "request_external" })).rejects.toMatchObject({ code: "foundation.not_found", }); expect(mocks.runWithRlsContext).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_z" }, expect.any(Function)); expect(mocks.tx.teamChat.findFirst).not.toHaveBeenCalled(); expect(mocks.tx.teamChat.create).not.toHaveBeenCalled(); }); it("serializes concurrent DM get-or-create calls and creates only one channel", async () => { let activeDm: ReturnType | null = null; let lockTail: Promise = Promise.resolve(); const create = vi.fn(async () => ({ id: "chat_dm", eventStreamId: "stream_dm" })); const createMany = vi.fn(async () => { activeDm = directMessageChannel(); return { count: 2 }; }); mocks.client.$transaction.mockImplementation(async (callback: (tx: Record) => Promise) => { let releaseLock: (() => void) | undefined; const transaction = { $queryRaw: vi.fn(async (query: TemplateStringsArray, ...values: unknown[]) => String(query).includes("target_tenant_user") ? [{ userId: values[1] }] : String(query).includes('permission_row."name"') ? mocks.currentPermissions.map((name) => ({ name })) : [{ id: "tenant_user_1" }] ), $executeRaw: vi.fn(async () => { const previousLock = lockTail; lockTail = new Promise((resolve) => { releaseLock = resolve; }); await previousLock; return 1; }), teamChat: { findFirst: vi.fn(async () => activeDm), create, }, teamChatMember: { createMany, }, teamChatEvent: { create: vi.fn(async ({ data }: { data: Record }) => ({ sequence: mocks.nextEventSequence++, occurredAt: NOW, tenantId: data.tenantId, chatId: data.chatId, type: data.type, actorUserId: data.actorUserId, entityId: data.entityId, requestId: data.requestId, data: data.data, })), }, }; try { return await callback(transaction); } finally { releaseLock?.(); } }); const [first, second] = await Promise.all([ getOrCreateDirectMessage({ ...dmContext, peerUserId: "user_a", requestId: "request_concurrent_1" }), getOrCreateDirectMessage({ ...dmContext, peerUserId: "user_a", requestId: "request_concurrent_2" }), ]); expect(create).toHaveBeenCalledOnce(); expect(createMany).toHaveBeenCalledOnce(); expect([first.created, second.created].sort()).toEqual([false, true]); expect(first.chatId).toBe("chat_dm"); expect(second.chatId).toBe("chat_dm"); }); });