Refresh HiveGrid Cloud reference snapshot
This commit is contained in:
1 parent
5e99e14772
commit
7f88026f79
5955 files changed
+1177325
-188362
No files matched your search
@@ -0,0 +1,494 @@
|
||||
import { logActivity } from "@hivegrid/activity";
|
||||
import type { Prisma } from "@hivegrid/db/prisma-browser";
|
||||
import type { DbTransactionClient } from "@hivegrid/db/transactions.server";
|
||||
import { CatalogError, foundationErrors, withTenantScope } from "@hivegrid/foundation";
|
||||
import { extractChatMentions, type ChatMention, type ChatMentionType } from "@hivegrid/realtime";
|
||||
|
||||
import { chatErrors } from "./errors.js";
|
||||
import { CHAT_PERMISSIONS } from "./permissions.js";
|
||||
import { runChatRepositoryTransaction } from "./repository.server.js";
|
||||
import type { ChatRepositoryContext } from "./types.js";
|
||||
|
||||
const ACTIVE_TENANT_USER_STATUS = 2;
|
||||
const MAX_QUERY_LENGTH = 120;
|
||||
const MAX_SUGGESTIONS = 10;
|
||||
const MAX_LABEL_LENGTH = 300;
|
||||
|
||||
export type ChatMentionSuggestion = Readonly<{
|
||||
type: ChatMentionType;
|
||||
id: string;
|
||||
label: string;
|
||||
detail: string | null;
|
||||
}>;
|
||||
|
||||
export type ListChatMentionSuggestionsInput = ChatRepositoryContext &
|
||||
Readonly<{
|
||||
chatId: string;
|
||||
query?: string;
|
||||
type?: ChatMentionType | null;
|
||||
limit?: number;
|
||||
}>;
|
||||
|
||||
export type ChatMentionChannel = Readonly<{
|
||||
id: string;
|
||||
kind: "project" | "group" | "dm";
|
||||
isPrivate: boolean;
|
||||
projektId: string | null;
|
||||
name: string | null;
|
||||
}>;
|
||||
|
||||
type VisibilityPrincipals = Readonly<{
|
||||
roleIds: readonly string[];
|
||||
groupIds: readonly string[];
|
||||
}>;
|
||||
|
||||
/**
|
||||
* Lists mention candidates through the same fresh-permission and FORCE-RLS
|
||||
* transaction boundary as channel reads. Results are intentionally bounded on
|
||||
* the server; the combobox never receives a tenant-wide directory dump.
|
||||
*/
|
||||
export async function listChatMentionSuggestions(input: ListChatMentionSuggestionsInput): Promise<readonly ChatMentionSuggestion[]> {
|
||||
const normalized = normalizeSuggestionInput(input);
|
||||
return runChatRepositoryTransaction(input, CHAT_PERMISSIONS.readOwnChannels, async (tx, currentPermissions) => {
|
||||
const channel = await requireMentionChannel(tx, input, normalized.chatId, true);
|
||||
const principals = await loadVisibilityPrincipals(tx, input);
|
||||
const types = normalized.type ? [normalized.type] : (["user", "project", "contact", "company"] as const);
|
||||
const suggestions: ChatMentionSuggestion[] = [];
|
||||
|
||||
for (const type of types) {
|
||||
const remaining = normalized.limit - suggestions.length;
|
||||
if (remaining <= 0) break;
|
||||
const rows = await listSuggestionsOfType(tx, input, channel, currentPermissions, principals, type, normalized.query, remaining);
|
||||
suggestions.push(...rows);
|
||||
}
|
||||
return suggestions;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts canonical tokens from the body and re-resolves every id and label.
|
||||
* Client-provided mention arrays and labels are never authoritative.
|
||||
*/
|
||||
export async function resolveChatMentionsInBodyWithTx(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
channel: ChatMentionChannel,
|
||||
body: string,
|
||||
currentPermissions: readonly string[]
|
||||
): Promise<ChatMention[]> {
|
||||
let extracted: ChatMention[];
|
||||
try {
|
||||
extracted = extractChatMentions(body);
|
||||
} catch {
|
||||
throw new CatalogError(chatErrors.invalidInput, { field: "body" });
|
||||
}
|
||||
if (extracted.length === 0) return [];
|
||||
|
||||
const principals = await loadVisibilityPrincipals(tx, context);
|
||||
const resolvedByKey = new Map<string, ChatMention>();
|
||||
for (const type of ["user", "project", "contact", "company"] as const) {
|
||||
const ids = [...new Set(extracted.filter((mention) => mention.type === type).map((mention) => mention.id))];
|
||||
if (ids.length === 0) continue;
|
||||
const rows = await resolveMentionsOfType(tx, context, channel, currentPermissions, principals, type, ids);
|
||||
for (const row of rows) resolvedByKey.set(mentionKey(row), row);
|
||||
}
|
||||
|
||||
const resolved = extracted.map((mention) => resolvedByKey.get(mentionKey(mention)));
|
||||
if (resolved.some((mention) => mention === undefined)) {
|
||||
throw new CatalogError(chatErrors.invalidInput, { mention: "not-visible" });
|
||||
}
|
||||
return resolved as ChatMention[];
|
||||
}
|
||||
|
||||
/** Writes the project timeline entry and each entity-mention timeline entry. */
|
||||
export async function logChatMessageActivitiesWithTx(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
input: Readonly<{
|
||||
channel: Pick<ChatMentionChannel, "id" | "projektId" | "name">;
|
||||
messageId: string;
|
||||
body: string;
|
||||
mentions: readonly ChatMention[];
|
||||
includeProjectChannelActivity: boolean;
|
||||
skipMentionKeys?: ReadonlySet<string>;
|
||||
action: "message_created" | "thread_reply_created" | "message_edited";
|
||||
}>
|
||||
): Promise<void> {
|
||||
const loggedSubjects = new Set<string>();
|
||||
|
||||
if (input.includeProjectChannelActivity && input.channel.projektId) {
|
||||
await logActivity(
|
||||
{
|
||||
tenantId: context.tenantId,
|
||||
actorUserId: context.userId,
|
||||
actorKind: "user",
|
||||
activityType: "chat_message",
|
||||
subjectType: "project",
|
||||
subjectId: input.channel.projektId,
|
||||
summaryText:
|
||||
input.action === "thread_reply_created"
|
||||
? "activity.runtime.chat.threadReplyCreated"
|
||||
: input.action === "message_edited"
|
||||
? "activity.runtime.chat.messageEdited"
|
||||
: "activity.runtime.chat.messageCreated",
|
||||
metadata: {
|
||||
sourceModule: "chat",
|
||||
chatAction: input.action,
|
||||
chatId: input.channel.id,
|
||||
messageId: input.messageId,
|
||||
},
|
||||
},
|
||||
{ client: tx }
|
||||
);
|
||||
loggedSubjects.add(`project\u0000${input.channel.projektId}`);
|
||||
}
|
||||
|
||||
for (const mention of input.mentions) {
|
||||
if (mention.type === "user") continue;
|
||||
const key = mentionKey(mention);
|
||||
if (input.skipMentionKeys?.has(key) || loggedSubjects.has(`${mention.type}\u0000${mention.id}`)) continue;
|
||||
await logActivity(
|
||||
{
|
||||
tenantId: context.tenantId,
|
||||
actorUserId: context.userId,
|
||||
actorKind: "user",
|
||||
activityType: "chat_message",
|
||||
subjectType: mention.type,
|
||||
subjectId: mention.id,
|
||||
summaryText: "activity.runtime.chat.entityMentioned",
|
||||
metadata: {
|
||||
sourceModule: "chat",
|
||||
chatAction: "entity_mentioned",
|
||||
chatId: input.channel.id,
|
||||
messageId: input.messageId,
|
||||
mentionType: mention.type,
|
||||
},
|
||||
},
|
||||
{ client: tx }
|
||||
);
|
||||
loggedSubjects.add(`${mention.type}\u0000${mention.id}`);
|
||||
}
|
||||
}
|
||||
|
||||
export function chatMentionKey(mention: Pick<ChatMention, "type" | "id">): string {
|
||||
return mentionKey(mention);
|
||||
}
|
||||
|
||||
async function requireMentionChannel(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
chatId: string,
|
||||
lockMembership: boolean
|
||||
): Promise<ChatMentionChannel> {
|
||||
if (lockMembership) {
|
||||
const rows = await tx.$queryRaw<Array<{ id: string }>>`
|
||||
SELECT mention_viewer."id"
|
||||
FROM "TeamChatMember" AS mention_viewer
|
||||
WHERE mention_viewer."tenantId" = ${context.tenantId}
|
||||
AND mention_viewer."chatId" = ${chatId}
|
||||
AND mention_viewer."userId" = ${context.userId}
|
||||
AND mention_viewer."leftAt" IS NULL
|
||||
FOR SHARE
|
||||
`;
|
||||
if (rows.length !== 1) throw new CatalogError(foundationErrors.notFound, { chat: "not-visible" });
|
||||
}
|
||||
const channel = await tx.teamChat.findFirst({
|
||||
where: withTenantScope(context.tenantId, {
|
||||
id: chatId,
|
||||
members: { some: withTenantScope(context.tenantId, { userId: context.userId, leftAt: null }) },
|
||||
}),
|
||||
select: { id: true, kind: true, isPrivate: true, projektId: true, name: true },
|
||||
});
|
||||
if (!channel) throw new CatalogError(foundationErrors.notFound, { chat: "not-visible" });
|
||||
return channel;
|
||||
}
|
||||
|
||||
async function loadVisibilityPrincipals(tx: DbTransactionClient, context: Pick<ChatRepositoryContext, "tenantId" | "userId">): Promise<VisibilityPrincipals> {
|
||||
const [roles, groups] = await Promise.all([
|
||||
tx.userRole.findMany({
|
||||
where: { tenantId: context.tenantId, userId: context.userId, role: { type: "app", OR: [{ tenantId: context.tenantId }, { tenantId: null }] } },
|
||||
select: { roleId: true },
|
||||
}),
|
||||
tx.groupUser.findMany({
|
||||
where: { userId: context.userId, group: { tenantId: context.tenantId } },
|
||||
select: { groupId: true },
|
||||
}),
|
||||
]);
|
||||
return {
|
||||
roleIds: [...new Set(roles.map((row) => row.roleId))],
|
||||
groupIds: [...new Set(groups.map((row) => row.groupId))],
|
||||
};
|
||||
}
|
||||
|
||||
async function listSuggestionsOfType(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
channel: ChatMentionChannel,
|
||||
permissions: readonly string[],
|
||||
principals: VisibilityPrincipals,
|
||||
type: ChatMentionType,
|
||||
query: string,
|
||||
limit: number
|
||||
): Promise<ChatMentionSuggestion[]> {
|
||||
if (type === "user") return listUserSuggestions(tx, context, channel, query, limit);
|
||||
if (type === "project") return listProjectSuggestions(tx, context, permissions, principals, query, limit);
|
||||
return listContactSuggestions(tx, context, permissions, type, query, limit);
|
||||
}
|
||||
|
||||
async function listUserSuggestions(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
channel: ChatMentionChannel,
|
||||
query: string,
|
||||
limit: number
|
||||
): Promise<ChatMentionSuggestion[]> {
|
||||
const memberIds = (
|
||||
await tx.teamChatMember.findMany({
|
||||
where: withTenantScope(context.tenantId, { chatId: channel.id, leftAt: null }),
|
||||
select: { userId: true },
|
||||
})
|
||||
).map((row) => row.userId);
|
||||
if (memberIds.length === 0) return [];
|
||||
const rows = await tx.tenantUser.findMany({
|
||||
where: withTenantScope(context.tenantId, {
|
||||
status: ACTIVE_TENANT_USER_STATUS,
|
||||
userId: { in: memberIds },
|
||||
user: {
|
||||
active: true,
|
||||
pendingDeletion: false,
|
||||
...(query
|
||||
? {
|
||||
OR: [
|
||||
{ firstName: { contains: query, mode: "insensitive" as const } },
|
||||
{ lastName: { contains: query, mode: "insensitive" as const } },
|
||||
{ email: { contains: query, mode: "insensitive" as const } },
|
||||
],
|
||||
}
|
||||
: {}),
|
||||
},
|
||||
}),
|
||||
select: { userId: true, user: { select: { firstName: true, lastName: true, email: true } } },
|
||||
take: Math.max(limit * 3, limit),
|
||||
});
|
||||
return rows
|
||||
.map((row) => ({
|
||||
type: "user" as const,
|
||||
id: row.userId,
|
||||
label: userDisplayName(row.user),
|
||||
detail: row.user.email,
|
||||
}))
|
||||
.sort(compareSuggestions)
|
||||
.slice(0, limit);
|
||||
}
|
||||
|
||||
async function listProjectSuggestions(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
permissions: readonly string[],
|
||||
principals: VisibilityPrincipals,
|
||||
query: string,
|
||||
limit: number
|
||||
): Promise<ChatMentionSuggestion[]> {
|
||||
const scope = projectVisibilityWhere(context, permissions, principals);
|
||||
if (scope === null) return [];
|
||||
const rows = await tx.projekt.findMany({
|
||||
where: withTenantScope(context.tenantId, {
|
||||
archivedAt: null,
|
||||
AND: [
|
||||
scope,
|
||||
...(query
|
||||
? [
|
||||
{
|
||||
OR: [
|
||||
{ projektname: { contains: query, mode: "insensitive" as const } },
|
||||
{ projektNummer: { contains: query, mode: "insensitive" as const } },
|
||||
],
|
||||
},
|
||||
]
|
||||
: []),
|
||||
],
|
||||
}),
|
||||
select: { id: true, projektNummer: true, projektname: true },
|
||||
take: Math.max(limit * 3, limit),
|
||||
});
|
||||
return rows
|
||||
.map((row) => ({ type: "project" as const, id: row.id, label: boundedLabel(`${row.projektNummer} · ${row.projektname}`), detail: row.projektNummer }))
|
||||
.sort(compareSuggestions)
|
||||
.slice(0, limit);
|
||||
}
|
||||
|
||||
async function listContactSuggestions(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
permissions: readonly string[],
|
||||
type: "contact" | "company",
|
||||
query: string,
|
||||
limit: number
|
||||
): Promise<ChatMentionSuggestion[]> {
|
||||
const scope = contactVisibilityWhere(context, permissions);
|
||||
if (scope === null) return [];
|
||||
const kontaktTyp = type === "company" ? ("organisation" as const) : ("privatperson" as const);
|
||||
const rows = await tx.kontakt.findMany({
|
||||
where: withTenantScope(context.tenantId, {
|
||||
kontaktTyp,
|
||||
archivedAt: null,
|
||||
AND: [
|
||||
scope,
|
||||
...(query
|
||||
? [
|
||||
{
|
||||
OR: [
|
||||
{ vorname: { contains: query, mode: "insensitive" as const } },
|
||||
{ nachname: { contains: query, mode: "insensitive" as const } },
|
||||
{ orgName: { contains: query, mode: "insensitive" as const } },
|
||||
{ primaerEmail: { contains: query, mode: "insensitive" as const } },
|
||||
],
|
||||
},
|
||||
]
|
||||
: []),
|
||||
],
|
||||
}),
|
||||
select: { id: true, vorname: true, nachname: true, orgName: true, primaerEmail: true },
|
||||
take: Math.max(limit * 3, limit),
|
||||
});
|
||||
return rows
|
||||
.map((row) => ({ type, id: row.id, label: kontaktDisplayName(row, type), detail: row.primaerEmail }))
|
||||
.sort(compareSuggestions)
|
||||
.slice(0, limit);
|
||||
}
|
||||
|
||||
async function resolveMentionsOfType(
|
||||
tx: DbTransactionClient,
|
||||
context: ChatRepositoryContext,
|
||||
channel: ChatMentionChannel,
|
||||
permissions: readonly string[],
|
||||
principals: VisibilityPrincipals,
|
||||
type: ChatMentionType,
|
||||
ids: readonly string[]
|
||||
): Promise<ChatMention[]> {
|
||||
if (type === "user") {
|
||||
const memberIds = (
|
||||
await tx.teamChatMember.findMany({
|
||||
where: withTenantScope(context.tenantId, { chatId: channel.id, leftAt: null, userId: { in: [...ids] } }),
|
||||
select: { userId: true },
|
||||
})
|
||||
).map((row) => row.userId);
|
||||
if (memberIds.length === 0) return [];
|
||||
const rows = await tx.tenantUser.findMany({
|
||||
where: withTenantScope(context.tenantId, {
|
||||
userId: { in: memberIds },
|
||||
status: ACTIVE_TENANT_USER_STATUS,
|
||||
user: { active: true, pendingDeletion: false },
|
||||
}),
|
||||
select: { userId: true, user: { select: { firstName: true, lastName: true, email: true } } },
|
||||
});
|
||||
return rows.map((row) => ({ type: "user", id: row.userId, label: userDisplayName(row.user) }));
|
||||
}
|
||||
|
||||
if (type === "project") {
|
||||
const scope = projectVisibilityWhere(context, permissions, principals);
|
||||
if (scope === null) return [];
|
||||
const rows = await tx.projekt.findMany({
|
||||
where: withTenantScope(context.tenantId, { id: { in: [...ids] }, archivedAt: null, AND: [scope] }),
|
||||
select: { id: true, projektNummer: true, projektname: true },
|
||||
});
|
||||
return rows.map((row) => ({ type, id: row.id, label: boundedLabel(`${row.projektNummer} · ${row.projektname}`) }));
|
||||
}
|
||||
|
||||
const scope = contactVisibilityWhere(context, permissions);
|
||||
if (scope === null) return [];
|
||||
const kontaktTyp = type === "company" ? ("organisation" as const) : ("privatperson" as const);
|
||||
const rows = await tx.kontakt.findMany({
|
||||
where: withTenantScope(context.tenantId, { id: { in: [...ids] }, kontaktTyp, archivedAt: null, AND: [scope] }),
|
||||
select: { id: true, vorname: true, nachname: true, orgName: true, primaerEmail: true },
|
||||
});
|
||||
return rows.map((row) => ({ type, id: row.id, label: kontaktDisplayName(row, type) }));
|
||||
}
|
||||
|
||||
function projectVisibilityWhere(
|
||||
context: ChatRepositoryContext,
|
||||
permissions: readonly string[],
|
||||
principals: VisibilityPrincipals
|
||||
): Prisma.ProjektWhereInput | null {
|
||||
const ownerConditions: Prisma.ProjektWhereInput[] = [];
|
||||
if (permissions.includes("projects.read_all")) {
|
||||
// No owner restriction.
|
||||
} else {
|
||||
if (permissions.includes("projects.read_own")) ownerConditions.push({ zustaendigePersonId: context.userId });
|
||||
if (permissions.includes("projects.read_own_pl")) ownerConditions.push({ projektleiterId: context.userId });
|
||||
if (permissions.includes("projects.read_own_member")) {
|
||||
ownerConditions.push({
|
||||
mitglieder: {
|
||||
some: withTenantScope(context.tenantId, {
|
||||
archivedAt: null,
|
||||
OR: [{ userId: context.userId }, ...(principals.groupIds.length > 0 ? [{ groupId: { in: [...principals.groupIds] } }] : [])],
|
||||
}),
|
||||
},
|
||||
});
|
||||
}
|
||||
if (ownerConditions.length === 0) return null;
|
||||
}
|
||||
const effectivePrincipals: Prisma.PipelineAccessWhereInput[] = [
|
||||
{ principalType: "user", principalId: context.userId },
|
||||
...principals.roleIds.map((principalId) => ({ principalType: "role" as const, principalId })),
|
||||
...principals.groupIds.map((principalId) => ({ principalType: "group" as const, principalId })),
|
||||
];
|
||||
return {
|
||||
AND: [
|
||||
...(ownerConditions.length > 0 ? [{ OR: ownerConditions }] : []),
|
||||
{ pipeline: { accessRules: { none: withTenantScope(context.tenantId, { kannSehen: false, OR: effectivePrincipals }) } } },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function contactVisibilityWhere(context: ChatRepositoryContext, permissions: readonly string[]): Prisma.KontaktWhereInput | null {
|
||||
if (permissions.includes("crm.read_all")) return {};
|
||||
if (permissions.includes("crm.read_own")) return { zustaendigerUserId: context.userId };
|
||||
return null;
|
||||
}
|
||||
|
||||
function normalizeSuggestionInput(input: ListChatMentionSuggestionsInput): { chatId: string; query: string; type: ChatMentionType | null; limit: number } {
|
||||
const chatId = normalizeIdentifier(input.chatId, "chatId");
|
||||
if (input.type !== undefined && input.type !== null && !["user", "project", "contact", "company"].includes(input.type)) {
|
||||
throw new CatalogError(chatErrors.invalidInput, { field: "type" });
|
||||
}
|
||||
const query = typeof input.query === "string" ? input.query.trim().slice(0, MAX_QUERY_LENGTH) : "";
|
||||
const limit = input.limit === undefined ? MAX_SUGGESTIONS : input.limit;
|
||||
if (!Number.isInteger(limit) || limit < 1 || limit > MAX_SUGGESTIONS) {
|
||||
throw new CatalogError(chatErrors.invalidInput, { field: "limit" });
|
||||
}
|
||||
return { chatId, query, type: input.type ?? null, limit };
|
||||
}
|
||||
|
||||
function normalizeIdentifier(value: unknown, field: string): string {
|
||||
if (typeof value !== "string") throw new CatalogError(chatErrors.invalidInput, { field });
|
||||
const normalized = value.trim();
|
||||
if (!normalized || normalized.length > 500 || normalized.includes("\0")) throw new CatalogError(chatErrors.invalidInput, { field });
|
||||
return normalized;
|
||||
}
|
||||
|
||||
function userDisplayName(user: { firstName: string; lastName: string; email: string }): string {
|
||||
return boundedLabel(`${user.firstName} ${user.lastName}`.trim() || user.email.trim());
|
||||
}
|
||||
|
||||
function kontaktDisplayName(
|
||||
row: { vorname: string | null; nachname: string | null; orgName: string | null; primaerEmail: string | null },
|
||||
type: "contact" | "company"
|
||||
): string {
|
||||
const label = type === "company" ? row.orgName?.trim() : `${row.vorname ?? ""} ${row.nachname ?? ""}`.trim();
|
||||
return boundedLabel(label || row.primaerEmail?.trim() || (type === "company" ? "Firma" : "Kontakt"));
|
||||
}
|
||||
|
||||
function boundedLabel(value: string): string {
|
||||
const normalized = value.trim().replace(/\s+/gu, " ");
|
||||
if (!normalized) throw new CatalogError(chatErrors.integrityFailure);
|
||||
return normalized.slice(0, MAX_LABEL_LENGTH);
|
||||
}
|
||||
|
||||
function compareSuggestions(left: ChatMentionSuggestion, right: ChatMentionSuggestion): number {
|
||||
return left.label.localeCompare(right.label, "de", { sensitivity: "base" }) || left.id.localeCompare(right.id);
|
||||
}
|
||||
|
||||
function mentionKey(mention: Pick<ChatMention, "type" | "id">): string {
|
||||
return `${mention.type}\u0000${mention.id}`;
|
||||
}
|
||||
Reference in new issue
Block a user