1078 lines
44 KiB
TypeScript
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");
|
|
});
|
|
});
|