Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,395 @@
import { describe, expect, it, vi } from "vitest";
import type { McpToolContext } from "./context.js";
import { decodeCursor } from "./pagination.js";
import { getVisibleContactDetail, listVisibleActivities, searchVisibleProjects } from "./read-tools-backend.js";
function contextWith(tx: Record<string, unknown>, permissions: string[]): McpToolContext {
const transaction = vi.fn(async (callback: (transactionClient: Record<string, unknown>) => Promise<unknown>) => callback(tx));
return {
principal: {
credential: { kind: "oauth", id: "token_1", name: "Test client" },
tenantId: "tenant_1",
tenantSlug: "acme",
userId: "user_1",
scopes: ["mcp:read"],
permissions,
},
readDb: { $transaction: transaction } as unknown as McpToolContext["readDb"],
writeDb: {} as McpToolContext["writeDb"],
request: { id: "request_1", ip: "127.0.0.1" },
};
}
function rlsExecutor() {
return vi.fn(async () => 1);
}
function firstCallArgument(mock: unknown): unknown {
return (mock as { mock: { calls: unknown[][] } }).mock.calls[0]?.[0];
}
describe("MCP read backend", () => {
it("searches member-visible projects, applies explicit user pipeline denies and omits monetary fields", async () => {
const createdAt = new Date("2026-07-12T10:00:00.000Z");
const olderCreatedAt = new Date("2026-07-11T10:00:00.000Z");
const projectFindMany = vi.fn(async () => [
{
id: "project_member",
projektNummer: "P-100",
projektname: "Visible project",
projekttyp: "SHK",
prioritaet: "hoch",
zustaendigePersonId: "owner_2",
projektleiterId: "lead_2",
deadline: new Date("2026-08-01T00:00:00.000Z"),
createdAt,
updatedAt: createdAt,
pipeline: { id: "pipeline_open", name: "Sales", typHint: "sales" },
stage: { id: "stage_new", name: "Neu", stageKind: "offen" },
potenziellerAuftragswert: "999999.00",
auftragsvolumen: "888888.00",
},
{
id: "project_next",
projektNummer: "P-099",
projektname: "Next project",
projekttyp: null,
prioritaet: "normal",
zustaendigePersonId: null,
projektleiterId: null,
deadline: null,
createdAt: olderCreatedAt,
updatedAt: olderCreatedAt,
pipeline: { id: "pipeline_open", name: "Sales", typHint: "sales" },
stage: { id: "stage_new", name: "Neu", stageKind: "offen" },
},
]);
const tx = {
$executeRaw: rlsExecutor(),
groupUser: { findMany: vi.fn(async () => [{ groupId: "group_1" }]) },
projektMitglied: { findMany: vi.fn() },
pipelineAccess: { findMany: vi.fn(async () => [{ pipelineId: "pipeline_denied" }]) },
projekt: { findMany: projectFindMany },
};
const ctx = contextWith(tx, ["projects.read_own_member"]);
const result = await searchVisibleProjects(ctx, {
query: "Visible",
pipelineId: "pipeline_open",
ownerUserId: "owner_2",
limit: 1,
});
expect(tx.$executeRaw).toHaveBeenCalledOnce();
expect(tx.$executeRaw).toHaveBeenCalledWith(expect.anything(), "tenant_1");
expect(projectFindMany).toHaveBeenCalledOnce();
const query = firstCallArgument(projectFindMany) as {
where: {
pipelineId: unknown;
AND: Array<{ OR?: unknown }>;
};
orderBy: unknown;
take: number;
select: Record<string, unknown>;
};
expect(query.where.pipelineId).toBe("pipeline_open");
expect(query.where.AND).toEqual(
expect.arrayContaining([
expect.objectContaining({
OR: expect.arrayContaining([
{
mitglieder: {
some: {
tenantId: "tenant_1",
archivedAt: null,
OR: [{ userId: "user_1" }, { groupId: { in: ["group_1"] } }],
},
},
},
]),
}),
{ pipelineId: { notIn: ["pipeline_denied"] } },
])
);
expect(tx.projektMitglied.findMany).not.toHaveBeenCalled();
expect(query.orderBy).toEqual([{ createdAt: "desc" }, { id: "desc" }]);
expect(query.take).toBe(2);
expect(query.select).not.toHaveProperty("potenziellerAuftragswert");
expect(query.select).not.toHaveProperty("auftragsvolumen");
expect(result.projects).toHaveLength(1);
expect(result.projects[0]).not.toHaveProperty("valuePotential");
expect(result.projects[0]).not.toHaveProperty("orderVolume");
expect(decodeCursor(result.nextCursor)).toEqual({ id: "project_member", createdAt: createdAt.toISOString() });
});
it("loads all contact channels but only relations whose counterpart is visible", async () => {
const now = new Date("2026-07-12T12:00:00.000Z");
const contactFindFirst = vi.fn(async () => ({
id: "company_1",
createdAt: now,
updatedAt: now,
kontaktTyp: "organisation" as const,
kontaktStatus: "kunde",
vorname: null,
nachname: null,
orgName: "Acme GmbH",
orgMerkmal: "gmbh",
primaerEmail: "office@acme.test",
primaerTelefon: "+49 30 123",
adresseId: "address_1",
zustaendigerUserId: "user_1",
language: "de",
emails: [
{ id: "email_1", email: "office@acme.test", primaer: true },
{ id: "email_2", email: "billing@acme.test", primaer: false },
],
telefone: [{ id: "phone_1", telefon: "+49 30 123", primaer: true }],
relationenVon: [
{ id: "relation_visible", zuKontaktId: "contact_visible", rolle: "hauptkontakt", kontext: "Visible context" },
{ id: "relation_hidden", zuKontaktId: "contact_hidden", rolle: "sekundaerkontakt", kontext: "Must not leak" },
],
relationenZu: [],
}));
const relatedFindMany = vi.fn(async () => [
{
id: "contact_visible",
kontaktTyp: "privatperson" as const,
vorname: "Ada",
nachname: "Lovelace",
orgName: null,
primaerEmail: "ada@acme.test",
primaerTelefon: null,
},
]);
const tx = {
$executeRaw: rlsExecutor(),
kontakt: { findFirst: contactFindFirst, findMany: relatedFindMany },
adresse: {
findFirst: vi.fn(async () => ({ strasse: "Main", hausnummer: "1", plz: "10115", ort: "Berlin", land: "DE" })),
},
};
const ctx = contextWith(tx, ["crm.read_own"]);
const result = await getVisibleContactDetail(ctx, "company_1");
expect(tx.$executeRaw).toHaveBeenCalledOnce();
const mainQuery = firstCallArgument(contactFindFirst) as {
where: Record<string, unknown>;
select: {
emails: { take: number };
telefone: { take: number };
relationenVon: { take: number };
relationenZu: { take: number };
};
};
expect(mainQuery.where).toMatchObject({ tenantId: "tenant_1", archivedAt: null });
expect(mainQuery.where.OR).toEqual([{ zustaendigerUserId: "user_1" }, { createdByUserId: "user_1" }]);
expect(mainQuery.select.emails.take).toBe(51);
expect(mainQuery.select.telefone.take).toBe(51);
expect(mainQuery.select.relationenVon.take).toBe(26);
expect(mainQuery.select.relationenZu.take).toBe(26);
const relatedQuery = firstCallArgument(relatedFindMany) as { where: Record<string, unknown> };
expect(relatedQuery.where).toMatchObject({ archivedAt: null, id: { in: ["contact_visible", "contact_hidden"] } });
expect(result.contact).toMatchObject({
id: "company_1",
type: "company",
name: "Acme GmbH",
language: "de",
emails: [
{ id: "email_1", value: "office@acme.test", isPrimary: true },
{ id: "email_2", value: "billing@acme.test", isPrimary: false },
],
address: { city: "Berlin", country: "DE" },
truncated: { emails: false, phones: false, relations: false },
});
expect(result.contact.relations).toEqual([
expect.objectContaining({
id: "relation_visible",
direction: "outgoing",
relatedContact: expect.objectContaining({ id: "contact_visible", type: "contact", name: "Ada Lovelace" }),
}),
]);
expect(JSON.stringify(result)).not.toContain("relation_hidden");
expect(JSON.stringify(result)).not.toContain("Must not leak");
});
it("caps contact channels and relation fan-out in one detail response", async () => {
const now = new Date("2026-07-12T12:00:00.000Z");
const contactFindMany = vi.fn(async () => []);
const tx = {
$executeRaw: rlsExecutor(),
kontakt: {
findFirst: vi.fn(async () => ({
id: "company_large",
createdAt: now,
updatedAt: now,
kontaktTyp: "organisation" as const,
kontaktStatus: "kunde",
vorname: null,
nachname: null,
orgName: "Large GmbH",
orgMerkmal: "gmbh",
primaerEmail: "office@large.test",
primaerTelefon: null,
adresseId: null,
zustaendigerUserId: "user_1",
language: "de",
emails: Array.from({ length: 101 }, (_, index) => ({ id: `email_${index}`, email: `mail${index}@large.test`, primaer: index === 0 })),
telefone: Array.from({ length: 101 }, (_, index) => ({ id: `phone_${index}`, telefon: `+49${index}`, primaer: index === 0 })),
relationenVon: Array.from({ length: 101 }, (_, index) => ({
id: `relation_${index}`,
zuKontaktId: `contact_${index}`,
rolle: "ansprechpartner",
kontext: null,
})),
relationenZu: [],
})),
findMany: contactFindMany,
},
adresse: { findFirst: vi.fn(async () => null) },
};
const result = await getVisibleContactDetail(contextWith(tx, ["crm.read_own"]), "company_large");
expect(result.contact.emails).toHaveLength(50);
expect(result.contact.phones).toHaveLength(50);
expect(result.contact.truncated).toEqual({ emails: true, phones: true, relations: true });
const relatedQuery = firstCallArgument(contactFindMany) as { where: { id: { in: string[] } } };
expect(relatedQuery.where.id.in).toHaveLength(25);
});
it("checks the contact/company discriminator and never queries activities for a mismatched subject", async () => {
const activityFindMany = vi.fn(async () => []);
const tx = {
$executeRaw: rlsExecutor(),
kontakt: { findFirst: vi.fn(async () => null) },
activity: { findMany: activityFindMany },
};
const ctx = contextWith(tx, ["crm.read_own"]);
await expect(listVisibleActivities(ctx, { subjectType: "company", subjectId: "person_1" })).rejects.toMatchObject({
status: 404,
code: "subject_not_found",
});
const subjectQuery = firstCallArgument(tx.kontakt.findFirst) as { where: Record<string, unknown> };
expect(subjectQuery.where.kontaktTyp).toBe("organisation");
expect(activityFindMany).not.toHaveBeenCalled();
});
it("checks task creator, assignee, watcher and group visibility before loading its activities", async () => {
const taskFindFirst = vi.fn(async () => ({ id: "task_1" }));
const activityFindMany = vi.fn(async () => []);
const tx = {
$executeRaw: rlsExecutor(),
groupUser: { findMany: vi.fn(async () => [{ groupId: "group_1" }]) },
task: { findFirst: taskFindFirst },
activity: { findMany: activityFindMany },
};
const ctx = contextWith(tx, ["tasks.read_own"]);
const result = await listVisibleActivities(ctx, { subjectType: "task", subjectId: "task_1" });
const subjectQuery = firstCallArgument(taskFindFirst) as { where: { OR: unknown[] } };
expect(subjectQuery.where.OR).toEqual(
expect.arrayContaining([
{ createdByUserId: "user_1" },
{ assignedToUserId: "user_1" },
{ watchers: { some: { tenantId: "tenant_1", userId: "user_1" } } },
{ assignedToGroupId: { in: ["group_1"] } },
])
);
expect(activityFindMany).toHaveBeenCalledOnce();
expect(result.activities).toEqual([]);
expect(result.nextCursor).toBeNull();
});
it("masks foreign e-mail summaries and never returns activity metadata or related references", async () => {
const firstCreatedAt = new Date("2026-07-12T12:00:00.000Z");
const secondCreatedAt = new Date("2026-07-12T11:00:00.000Z");
const thirdCreatedAt = new Date("2026-07-12T10:00:00.000Z");
const activityFindMany = vi.fn(async () => [
{
id: "activity_own",
createdAt: firstCreatedAt,
actorUserId: "user_1",
actorKind: "user",
activityType: "email_sent",
summaryText: "Visible own-mailbox subject",
metadata: { mailboxId: "mailbox_own", secret: "never-return" },
relatedEntityRefs: [{ type: "lead", id: "lead_secret" }],
},
{
id: "activity_foreign",
createdAt: secondCreatedAt,
actorUserId: "user_2",
actorKind: "user",
activityType: "email_sent",
summaryText: "Foreign mailbox subject must not leak",
metadata: { mailboxId: "mailbox_foreign", secret: "never-return" },
},
{
id: "activity_next",
createdAt: thirdCreatedAt,
actorUserId: null,
actorKind: "system",
activityType: "note_added",
summaryText: "Next page",
metadata: null,
},
]);
const tx = {
$executeRaw: rlsExecutor(),
kontakt: { findFirst: vi.fn(async () => ({ id: "company_1" })) },
activity: { findMany: activityFindMany },
emailIntegrationMailbox: { findMany: vi.fn(async () => [{ id: "mailbox_own" }]) },
};
const ctx = contextWith(tx, ["crm.read_own", "email.read_own"]);
const result = await listVisibleActivities(ctx, {
subjectType: "company",
subjectId: "company_1",
activityType: "email_sent",
limit: 2,
});
expect(tx.$executeRaw).toHaveBeenCalledOnce();
const activityQuery = firstCallArgument(activityFindMany) as {
where: Record<string, unknown>;
orderBy: unknown;
take: number;
select: Record<string, unknown>;
};
expect(activityQuery.where).toMatchObject({
tenantId: "tenant_1",
subjectType: "company",
subjectId: "company_1",
activityType: "email_sent",
});
expect(activityQuery.orderBy).toEqual([{ createdAt: "desc" }, { id: "desc" }]);
expect(activityQuery.take).toBe(3);
expect(activityQuery.select).not.toHaveProperty("relatedEntityRefs");
expect(result.activities).toEqual([
expect.objectContaining({
id: "activity_own",
summaryText: "Visible own-mailbox subject",
summaryTextTruncated: false,
summaryTextIsUntrustedData: true,
}),
expect.objectContaining({
id: "activity_foreign",
summaryText: "Email activity is not visible to this user.",
summaryTextTruncated: false,
summaryTextIsUntrustedData: true,
}),
]);
expect(decodeCursor(result.nextCursor)).toEqual({ id: "activity_foreign", createdAt: secondCreatedAt.toISOString() });
const serialized = JSON.stringify(result);
expect(serialized).not.toContain("mailbox_own");
expect(serialized).not.toContain("mailbox_foreign");
expect(serialized).not.toContain("never-return");
expect(serialized).not.toContain("lead_secret");
expect(serialized).not.toContain("Foreign mailbox subject must not leak");
});
});