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

1078 lines
44 KiB
TypeScript

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> = {}
): 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<string, unknown> = {}) {
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<string, unknown> = {}) {
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<string, unknown> }) => ({
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<string, unknown>) => ({
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<typeof directMessageChannel> | null = null;
let lockTail: Promise<void> = 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<string, unknown>) => Promise<unknown>) => {
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<void>((resolve) => {
releaseLock = resolve;
});
await previousLock;
return 1;
}),
teamChat: {
findFirst: vi.fn(async () => activeDm),
create,
},
teamChatMember: {
createMany,
},
teamChatEvent: {
create: vi.fn(async ({ data }: { data: Record<string, unknown> }) => ({
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");
});
});