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,173 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, actor } = vi.hoisted(() => ({
service: {
getContactDetail: vi.fn(),
createTask: vi.fn(),
completeTask: vi.fn(),
},
actor: vi.fn((reason: string) => ({ adminUserId: "admin_1", reason })),
}));
const { telephonyActions } = vi.hoisted(() => ({
telephonyActions: { queueOutboundCall: vi.fn() },
}));
vi.mock(
"~/components/screens/admin/sales/tasks/AdminSalesContactDetailPage",
() => ({ AdminSalesContactDetailPage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
locale: "de-DE",
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-sales-tasks.server", () => ({
runAsAdminSalesTaskOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
service,
actor,
adminUserId: "admin_1",
timeZone: "Europe/Berlin",
canWrite: true,
})
),
}));
vi.mock("~/services/admin/admin-telephony-connections.server", () => ({
runAsAdminTelephonyOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
actions: telephonyActions,
actor,
adminUserId: "admin_1",
})
),
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./$id";
describe("admin sales contact detail route", () => {
beforeEach(() => {
vi.clearAllMocks();
service.getContactDetail.mockResolvedValue({
id: "contact_1",
firstName: "Ada",
lastName: "Lovelace",
jobTitle: "CTO",
email: "ada@example.test",
phone: "+49 30 123456",
locale: "de-DE",
timeZone: null,
ownerAdminUserId: "admin_1",
company: { id: "company_1", name: "Analytical Engines" },
deals: [],
tasks: [],
activities: [],
});
service.createTask.mockResolvedValue({ id: "task_1" });
});
it("builds a server-side contact timeline behind CRM read permission", async () => {
const result = await loader({
request: new Request(
"https://admin.hivegrid.de/sales/contacts/contact_1"
),
params: { id: "contact_1" },
context: {},
} as never);
expect(runAsAdminSalesTaskOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(service.getContactDetail).toHaveBeenCalledWith("contact_1");
expect(result.vm).toMatchObject({
id: "contact_1",
name: "Ada Lovelace",
canWrite: true,
});
});
it("validates and creates a recurring contextual task atomically through the service", async () => {
const response = await action({
request: new Request(
"https://admin.hivegrid.de/sales/contacts/contact_1",
{
method: "POST",
body: new URLSearchParams({
intent: "create",
title: "Demo nachfassen",
assignedToAdminUserId: "admin_1",
dueAt: "2026-07-27T09:00:00.000Z",
timeZone: "Europe/Berlin",
priority: "high",
recurrenceFrequency: "weekly",
recurrenceInterval: "1",
reason: "Follow-up am Kontakt angelegt",
}),
}
),
params: { id: "contact_1" },
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminSalesTaskOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.write",
expect.any(Function)
);
expect(service.createTask).toHaveBeenCalledWith(
expect.objectContaining({
title: "Demo nachfassen",
contactId: "contact_1",
assignedToAdminUserId: "admin_1",
recurrence: expect.objectContaining({
frequency: "weekly",
interval: 1,
}),
actor: {
adminUserId: "admin_1",
reason: "Follow-up am Kontakt angelegt",
},
})
);
expect(response.status).toBe(303);
});
it("starts a click-to-call request through the telephony permission boundary", async () => {
const response = await action({
request: new Request(
"https://admin.hivegrid.de/sales/contacts/contact_1",
{
method: "POST",
body: new URLSearchParams({ intent: "call" }),
}
),
params: { id: "contact_1" },
context: {},
} as never);
expect(runAsAdminTelephonyOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.phone.call",
expect.any(Function)
);
expect(telephonyActions.queueOutboundCall).toHaveBeenCalledWith(
expect.objectContaining({
adminUserId: "admin_1",
contactId: "contact_1",
})
);
expect(response.status).toBe(303);
});
});
@@ -0,0 +1,205 @@
import {
adminSalesTaskCompleteActionSchema,
adminSalesTaskCreateActionSchema,
adminSalesContactNoteActionSchema,
buildAdminSalesContactDetailVM,
} from "@hivegrid/view-models";
import { randomUUID } from "node:crypto";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useTranslation } from "react-i18next";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminSalesContactDetailPage } from "~/components/screens/admin/sales/tasks/AdminSalesContactDetailPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const { locale } = await getTranslations(request);
return runAsAdminSalesTaskOperator(request, "admin_sales.crm.read", async ({ service, adminUserId, timeZone, canWrite }) => {
const contact = await service.getContactDetail(params.id ?? "");
if (!contact) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
return {
currentAdminUserId: adminUserId,
vm: buildAdminSalesContactDetailVM({
now: new Date(),
locale,
defaultTimeZone: timeZone,
contact,
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildDealHref: (dealId) =>
adminPath(`sales/deals/${encodeURIComponent(dealId)}`, {
mode: "host-aware",
}),
buildRecordingHref: (recordingId) => adminPath(`sales/calls/recordings/${encodeURIComponent(recordingId)}`, { mode: "host-aware" }),
canWrite,
}),
};
});
}
export async function action({ request, params }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
const contactId = params.id ?? "";
try {
if (intent === "call") {
await runAsAdminTelephonyOperator(request, "admin_sales.phone.call", ({ actions, adminUserId, actor }) =>
actions.queueOutboundCall({
adminUserId,
contactId,
idempotencyKey: randomUUID(),
actor: actor(t("admin.sales.telephony.audit.queue_call")),
})
);
const target = new URL(adminPath("sales/calls", { mode: "host-aware" }), request.url);
target.searchParams.set("toast", "admin.sales.contacts.toast.callQueued");
return Response.redirect(target, 303);
}
if (intent === "add-note") {
const command = adminSalesContactNoteActionSchema.parse({
contactId,
body: form.get("body"),
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(request, "admin_sales.crm.write", ({ service, actor }) =>
service.addContactNote({
contactId,
body: command.body,
actor: actor(command.reason),
})
);
const target = new URL(
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
request.url
);
target.searchParams.set("toast", "admin.sales.contacts.toast.noteAdded");
return Response.redirect(target, 303);
}
await runAsAdminSalesTaskOperator(request, "admin_sales.crm.write", async ({ service, actor }) => {
if (intent === "create") {
const command = adminSalesTaskCreateActionSchema.parse({
title: form.get("title"),
description: nullableFormString(form.get("description")),
contactId,
dealId: nullableFormString(form.get("dealId")),
assignedToAdminUserId: form.get("assignedToAdminUserId"),
dueAt: form.get("dueAt"),
timeZone: form.get("timeZone"),
reminderAt: nullableFormString(form.get("reminderAt")),
priority: form.get("priority"),
recurrenceFrequency: nullableFormString(form.get("recurrenceFrequency")),
recurrenceInterval: Number(form.get("recurrenceInterval")),
recurrenceEndsAt: nullableFormString(form.get("recurrenceEndsAt")),
reason: form.get("reason"),
});
await service.createTask({
...command,
description: command.description,
contactId,
dealId: command.dealId,
dueAt: new Date(command.dueAt),
reminderAt: command.reminderAt ? new Date(command.reminderAt) : null,
recurrence: command.recurrenceFrequency
? {
frequency: command.recurrenceFrequency,
interval: command.recurrenceInterval,
endsAt: command.recurrenceEndsAt ? new Date(command.recurrenceEndsAt) : null,
}
: null,
actor: actor(command.reason),
});
return;
}
if (intent === "complete") {
const command = adminSalesTaskCompleteActionSchema.parse({
taskId: form.get("taskId"),
reason: form.get("reason"),
});
await service.completeTask({
taskId: command.taskId,
actor: actor(command.reason),
});
return;
}
throw new Error("INVALID_INTENT");
});
const target = new URL(
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
request.url
);
target.searchParams.set("toast", intent === "complete" ? "admin.sales.tasks.toast.completed" : "admin.sales.tasks.toast.created");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.tasks.errors.actionFailed") }, { status: 400 });
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesContactDetailRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm, currentAdminUserId } = useLoaderData<typeof loader>();
const actionData = useActionData() as { readonly error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const submitIntent = (intent: string, input: Record<string, unknown>) => {
const form = appendCSRFToken(new FormData());
form.set("intent", intent);
for (const [key, value] of Object.entries(input)) {
if (value !== null && value !== undefined) form.set(key, String(value));
}
submit(form, { method: "post" });
};
return (
<AdminSalesContactDetailPage
vm={vm}
currentAdminUserId={currentAdminUserId}
backHref={adminPath("sales/deals", { mode: "host-aware" })}
emailComposeHref={
vm.email
? `${adminPath("sales/email/scheduled", { mode: "host-aware" })}?contactId=${encodeURIComponent(vm.id)}&to=${encodeURIComponent(vm.email)}`
: null
}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error ?? null}
actions={{
onCreateTask: (input) => submitIntent("create", input),
onAddNote: (body) =>
submitIntent("add-note", {
body,
reason: t("admin.sales.data.audit.noteCreated"),
}),
onCompleteTask: (taskId) =>
submitIntent("complete", {
taskId,
reason: t("admin.sales.tasks.audit.completed"),
}),
onCall: () => submitIntent("call", {}),
}}
/>
);
}
function nullableFormString(value: FormDataEntryValue | null): string | null {
return typeof value === "string" && value.trim() ? value.trim() : null;
}
@@ -0,0 +1,168 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, actor, helpers } = vi.hoisted(() => ({
service: {
listWorkspace: vi.fn(),
createTag: vi.fn(),
createCustomField: vi.fn(),
bulkUpdateContacts: vi.fn(),
},
actor: vi.fn((reason: string) => ({ adminUserId: "admin_1", reason })),
helpers: {
prepare: vi.fn(),
confirm: vi.fn(),
exportContacts: vi.fn(),
},
}));
vi.mock(
"~/components/screens/admin/sales/data/AdminSalesContactsPage",
() => ({ AdminSalesContactsPage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
locale: "de-DE",
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-sales-data.server", () => ({
runAsAdminSalesDataOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
service,
actor,
adminUserId: "admin_1",
canWrite: true,
canExport: true,
})
),
prepareAdminSalesContactsImport: helpers.prepare,
confirmAdminSalesContactsImport: helpers.confirm,
requestAdminSalesContactsExport: helpers.exportContacts,
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./index";
describe("admin sales contacts data route", () => {
beforeEach(() => {
vi.clearAllMocks();
service.listWorkspace.mockResolvedValue({
companies: [],
contacts: [],
tags: [],
customFields: [],
importJobs: [],
exportJobs: [],
});
service.createTag.mockResolvedValue({ id: "tag_1" });
});
it("builds the tenantless data-management VM through CRM read", async () => {
const result = await loader({
request: new Request("https://admin.hivegrid.de/sales/contacts"),
params: {},
context: {},
} as never);
expect(runAsAdminSalesDataOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(result.vm).toMatchObject({
status: "empty",
permissions: { canRead: true, canWrite: true, canExport: true },
});
});
it("validates CSRF and creates tags through the smallest write permission", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/contacts", {
method: "POST",
body: new URLSearchParams({
intent: "create-tag",
name: "Kunde",
color: "#2563eb",
reason: "Sales-Tag anlegen",
}),
}),
params: {},
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminSalesDataOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.write",
expect.any(Function)
);
expect(service.createTag).toHaveBeenCalledWith({
name: "Kunde",
color: "#2563eb",
actor: { adminUserId: "admin_1", reason: "Sales-Tag anlegen" },
});
expect(await response.json()).toEqual({
success: "admin.sales.data.feedback.tagCreated",
});
});
it("keeps preview and confirmation separate before queueing", async () => {
helpers.prepare.mockResolvedValue({
job: { id: "import_1", fileName: "kontakte.csv" },
preview: {
headers: ["Vorname", "Nachname"],
rowCount: 1,
suggestedMapping: [
"Vorname=firstName",
"Nachname=lastName",
],
},
});
const previewForm = new FormData();
previewForm.set("intent", "preview-import");
previewForm.set(
"file",
new File(["Vorname,Nachname\nAda,Lovelace\n"], "kontakte.csv", {
type: "text/csv",
})
);
const previewResponse = await action({
request: new Request("https://admin.hivegrid.de/sales/contacts", {
method: "POST",
body: previewForm,
}),
params: {},
context: {},
} as never);
expect(helpers.prepare).toHaveBeenCalledOnce();
expect(helpers.confirm).not.toHaveBeenCalled();
expect(await previewResponse.json()).toMatchObject({
preview: { jobId: "import_1", rowCount: 1 },
});
await action({
request: new Request("https://admin.hivegrid.de/sales/contacts", {
method: "POST",
body: new URLSearchParams({
intent: "confirm-import",
importJobId: "import_1",
reason: "Geprüften Import starten",
}),
}),
params: {},
context: {},
} as never);
expect(helpers.confirm).toHaveBeenCalledWith(
expect.objectContaining({
importJobId: "import_1",
reason: "Geprüften Import starten",
})
);
});
});
@@ -0,0 +1,92 @@
import { useTranslation } from "react-i18next";
import {
useActionData,
useLoaderData,
useNavigation,
useSubmit,
} from "react-router";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { AdminSalesContactsPage } from "~/components/screens/admin/sales/data/AdminSalesContactsPage";
import {
loadAdminSalesDataRoute,
mutateAdminSalesDataRoute,
type AdminSalesDataActionData,
} from "~/services/admin/admin-sales-data-route.server";
import { appendCSRFToken } from "~/utils/csrf";
export const loader = loadAdminSalesDataRoute;
export const action = mutateAdminSalesDataRoute;
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesContactsRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as AdminSalesDataActionData | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const submitIntent = (
intent: string,
values: Record<string, string | Blob | readonly string[] | number | boolean>
) => {
const form = appendCSRFToken(new FormData());
form.set("intent", intent);
for (const [key, value] of Object.entries(values)) {
form.set(
key,
Array.isArray(value)
? JSON.stringify(value)
: value instanceof Blob
? value
: String(value)
);
}
submit(form, { method: "post", encType: "multipart/form-data" });
};
return (
<AdminSalesContactsPage
vm={vm}
preview={actionData?.preview ?? null}
submitting={navigation.state === "submitting"}
successMessage={actionData?.success ?? null}
errorMessage={actionData?.error ?? null}
actions={{
onPreviewImport: (file) => submitIntent("preview-import", { file }),
onConfirmImport: (importJobId) =>
submitIntent("confirm-import", {
importJobId,
reason: t("admin.sales.data.audit.importConfirmed"),
}),
onExport: (contactIds) =>
submitIntent("export", {
contactIds,
reason: t("admin.sales.data.audit.exportRequested"),
}),
onCreateTag: (input) =>
submitIntent("create-tag", {
name: input.name,
color: input.color ?? "",
reason: t("admin.sales.data.audit.tagCreated"),
}),
onCreateCustomField: (input) =>
submitIntent("create-field", {
...input,
options: input.options,
reason: t("admin.sales.data.audit.fieldCreated"),
}),
onBulkUpdate: (input) =>
submitIntent("bulk-update", {
contactIds: input.contactIds,
locale: input.locale ?? "",
localeChanged: input.locale !== null,
addTagIds: input.addTagIds,
reason: t("admin.sales.data.audit.contactsUpdated"),
}),
}}
/>
);
}