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,92 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import { getRlsExecutionContext } from "@hivegrid/db/rls-context.server";
import { signClickTarget } from "@hivegrid/email-sequences/click-tracking-token";
const mocks = vi.hoisted(() => ({
updateMany: vi.fn(),
resolveDelivery: vi.fn(),
}));
vi.mock("~/utils/db.server", () => ({
db: { emailSequenceStepDelivery: { updateMany: mocks.updateMany } },
}));
vi.mock("@hivegrid/db/rls-resolvers.server", () => ({
resolveEmailSequenceDeliveryRlsIdentity: mocks.resolveDelivery,
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: () => "Dieser Link ist ungültig oder abgelaufen." })),
}));
const { loader } = await import("./track-click.$deliveryId");
const secret = "0123456789abcdef0123456789abcdef0123456789abcdef";
const deliveryId = "delivery_1";
const targetUrl = "https://destination.example/path";
beforeEach(() => {
vi.clearAllMocks();
process.env.MARKETING_TOKEN_SECRET = secret;
mocks.updateMany.mockImplementation(async () => {
expect(getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1" });
return { count: 1 };
});
mocks.resolveDelivery.mockResolvedValue({ tenantId: "tenant_1", resourceId: deliveryId });
});
describe("email click tracker", () => {
it("rejects an unsigned target without touching delivery state", async () => {
const response = await loader({
params: { deliveryId },
request: new Request(`https://app.example/email/track-click/${deliveryId}?u=${encodeURIComponent(targetUrl)}`),
} as never);
expect(response.status).toBe(400);
await expect(response.text()).resolves.toBe("Dieser Link ist ungültig oder abgelaufen.");
expect(mocks.updateMany).not.toHaveBeenCalled();
});
it("redirects only when the target and delivery id match the signature", async () => {
const signature = signClickTarget({ deliveryId, targetUrl, secret });
const url = new URL(`https://app.example/email/track-click/${deliveryId}`);
url.searchParams.set("u", targetUrl);
url.searchParams.set("s", signature);
const response = await loader({ params: { deliveryId }, request: new Request(url) } as never);
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe(targetUrl);
expect(response.headers.get("Referrer-Policy")).toBe("no-referrer");
expect(response.headers.get("Cache-Control")).toBe("no-store");
expect(mocks.resolveDelivery).toHaveBeenCalledWith(deliveryId);
expect(mocks.updateMany).toHaveBeenCalledOnce();
});
it("keeps a valid redirect working when the delivery cannot be resolved without writing", async () => {
mocks.resolveDelivery.mockResolvedValueOnce(null);
const signature = signClickTarget({ deliveryId, targetUrl, secret });
const url = new URL(`https://app.example/email/track-click/${deliveryId}`);
url.searchParams.set("u", targetUrl);
url.searchParams.set("s", signature);
const response = await loader({ params: { deliveryId }, request: new Request(url) } as never);
expect(response.status).toBe(302);
expect(mocks.updateMany).not.toHaveBeenCalled();
});
it("rejects a signed URL after its target is changed", async () => {
const signature = signClickTarget({ deliveryId, targetUrl, secret });
const url = new URL(`https://app.example/email/track-click/${deliveryId}`);
url.searchParams.set("u", "https://evil.example/phish");
url.searchParams.set("s", signature);
const response = await loader({ params: { deliveryId }, request: new Request(url) } as never);
expect(response.status).toBe(400);
expect(mocks.updateMany).not.toHaveBeenCalled();
});
});
@@ -1,11 +1,11 @@
/**
* Marketing-Funnel Phase 3 — click-through tracking + redirect (Phase 05 #80).
*
* GET /email/track-click/:deliveryId?u=<encoded-target-url>
* GET /email/track-click/:deliveryId?u=<encoded-target-url>&s=<signature>
*
* Records the first clickedAt for the delivery row and 302-redirects
* the browser to the original href. Only http(s) URLs are accepted
* to prevent open-redirect abuse (e.g. javascript: / data: schemes).
* the browser to the original href. The target and delivery id are bound by
* an HMAC so the public endpoint cannot be repurposed as an open redirect.
*
* Idempotent: subsequent clicks never overwrite the first-touch
* timestamp. Stats jobs aggregate raw counts per delivery.
@@ -13,40 +13,38 @@
import type { LoaderFunctionArgs } from "react-router";
import { redirect } from "react-router";
import { runWithRlsContext } from "@hivegrid/db/rls-context.server";
import { resolveEmailSequenceDeliveryRlsIdentity } from "@hivegrid/db/rls-resolvers.server";
import { verifyClickTargetSignature } from "@hivegrid/email-sequences/click-tracking-token";
import { db } from "~/utils/db.server";
import { createScopedLogger } from "~/utils/logger.server";
import { getTranslations } from "~/locale/i18next.server";
const logger = createScopedLogger("marketing.tracking.click");
function isSafeRedirect(url: string): boolean {
try {
const parsed = new URL(url);
return parsed.protocol === "https:" || parsed.protocol === "http:";
} catch {
return false;
}
}
export async function loader({ params, request }: LoaderFunctionArgs): Promise<Response> {
const deliveryId = params.deliveryId ?? "";
const url = new URL(request.url);
const target = url.searchParams.get("u") ?? "";
if (!isSafeRedirect(target)) {
logger.warn({ op: "marketing.tracking.click.unsafe_url", deliveryId }, "click target rejected");
return new Response("Invalid redirect target", { status: 400 });
const signature = url.searchParams.get("s");
if (!verifyClickTargetSignature({ deliveryId, targetUrl: target, signature })) {
const { t } = await getTranslations(request);
return new Response(t("mail:tracking.invalidOrExpiredLink"), { status: 400 });
}
if (deliveryId.length > 0) {
try {
await db.emailSequenceStepDelivery.updateMany({
where: { id: deliveryId, clickedAt: null },
data: { clickedAt: new Date() },
});
const identity = await resolveEmailSequenceDeliveryRlsIdentity(deliveryId);
if (identity) {
await runWithRlsContext({ tenantId: identity.tenantId }, () =>
db.emailSequenceStepDelivery.updateMany({
where: { id: identity.resourceId, clickedAt: null },
data: { clickedAt: new Date() },
})
);
}
} catch (err) {
logger.warn(
{ op: "marketing.tracking.click.error", deliveryId, errorName: (err as Error)?.name },
"click tracker update failed"
);
logger.warn({ op: "marketing.tracking.click.error", deliveryId, errorName: (err as Error)?.name }, "click tracker update failed");
}
}
return redirect(target);
return redirect(target, { headers: { "Referrer-Policy": "no-referrer", "Cache-Control": "no-store" } });
}
@@ -0,0 +1,51 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import { getRlsExecutionContext } from "@hivegrid/db/rls-context.server";
const mocks = vi.hoisted(() => ({
updateMany: vi.fn(),
resolveDelivery: vi.fn(),
}));
vi.mock("~/utils/db.server", () => ({
db: { emailSequenceStepDelivery: { updateMany: mocks.updateMany } },
}));
vi.mock("@hivegrid/db/rls-resolvers.server", () => ({
resolveEmailSequenceDeliveryRlsIdentity: mocks.resolveDelivery,
}));
const { loader } = await import("./track-open.$deliveryId[.gif]");
describe("email open tracker RLS bootstrap", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.resolveDelivery.mockResolvedValue({ tenantId: "tenant_1", resourceId: "delivery_1" });
mocks.updateMany.mockImplementation(async () => {
expect(getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1" });
return { count: 1 };
});
});
it("resolves the delivery before recording the tenant-scoped open", async () => {
const response = await loader({ params: { deliveryId: "delivery_1" } } as never);
expect(response.status).toBe(200);
expect(response.headers.get("Content-Type")).toBe("image/gif");
expect(mocks.resolveDelivery).toHaveBeenCalledWith("delivery_1");
expect(mocks.updateMany).toHaveBeenCalledWith({
where: { id: "delivery_1", openedAt: null },
data: { openedAt: expect.any(Date) },
});
});
it("returns the pixel without a write for an unknown delivery", async () => {
mocks.resolveDelivery.mockResolvedValueOnce(null);
const response = await loader({ params: { deliveryId: "unknown" } } as never);
expect(response.status).toBe(200);
expect(mocks.updateMany).not.toHaveBeenCalled();
});
});
@@ -12,32 +12,33 @@
*/
import type { LoaderFunctionArgs } from "react-router";
import { runWithRlsContext } from "@hivegrid/db/rls-context.server";
import { resolveEmailSequenceDeliveryRlsIdentity } from "@hivegrid/db/rls-resolvers.server";
import { db } from "~/utils/db.server";
import { createScopedLogger } from "~/utils/logger.server";
const logger = createScopedLogger("marketing.tracking.open");
// 1x1 transparent GIF (43 bytes).
const PIXEL = Buffer.from(
"47494638396101000100800000FFFFFF00000021F90401000001002C00000000010001000002024401003B",
"hex"
);
const PIXEL = Buffer.from("47494638396101000100800000FFFFFF00000021F90401000001002C00000000010001000002024401003B", "hex");
export async function loader({ params }: LoaderFunctionArgs): Promise<Response> {
const deliveryId = params.deliveryId ?? "";
if (deliveryId.length > 0) {
try {
// Use updateMany so a missing row is a soft no-op, not a P2025
// exception; and only flip openedAt the FIRST time.
await db.emailSequenceStepDelivery.updateMany({
where: { id: deliveryId, openedAt: null },
data: { openedAt: new Date() },
});
const identity = await resolveEmailSequenceDeliveryRlsIdentity(deliveryId);
if (identity) {
// Use updateMany so a missing row is a soft no-op, not a P2025
// exception; and only flip openedAt the FIRST time.
await runWithRlsContext({ tenantId: identity.tenantId }, () =>
db.emailSequenceStepDelivery.updateMany({
where: { id: identity.resourceId, openedAt: null },
data: { openedAt: new Date() },
})
);
}
} catch (err) {
logger.warn(
{ op: "marketing.tracking.open.error", deliveryId, errorName: (err as Error)?.name },
"open tracker update failed"
);
logger.warn({ op: "marketing.tracking.open.error", deliveryId, errorName: (err as Error)?.name }, "open tracker update failed");
}
}
return new Response(PIXEL, {