Track HiveGrid Cloud planning reference

This commit is contained in:
david committed 2026-06-26 20:48:01 +02:00
1 parent b3d5ea6764
commit e341c5938a
5784 files changed
+1104929 -3

No files matched your search

@@ -0,0 +1,92 @@
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { CampaignWithDetails, getCampaign, deleteCampaign, updateCampaign } from "../db/campaigns.db.server";
import { EmailSenderWithoutApiKey, getAllEmailSenders } from "../db/emailSender";
import EmailMarketingService from "../services/EmailMarketingService";
import { EntityWithDetails, getAllEntities } from "~/utils/db/entities/entities.db.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { adminPath, appPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
import { requireEmailMarketingMutationAccess } from "./emailMarketingAccess.server";
export namespace Campaigns_Edit {
export type LoaderData = {
title: string;
item: CampaignWithDetails;
emailSenders: EmailSenderWithoutApiKey[];
allEntities: EntityWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
const item = await getCampaign(params.id!, tenantId);
if (!item) {
return redirect(params.tenant ? appPath({ tenantSlug: params.tenant, path: "email-marketing/campaigns", mode: "host-aware" }) : adminPath("email-marketing/campaigns", { mode: "host-aware" }));
}
const emailSenders = await getAllEmailSenders(tenantId);
const data: LoaderData = {
title: `${item.name} | ${process.env.APP_NAME}`,
item,
emailSenders,
allEntities: await getAllEntities({ tenantId, active: true }),
};
return data;
};
export type ActionData = {
error?: string;
success?: string;
};
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
await requireEmailMarketingMutationAccess({ request, params, tenantId });
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const item = await getCampaign(params.id!, tenantId);
if (!item) {
return Response.json({ error: t("shared.notFound") }, { status: 404 });
}
if (action === "delete") {
try {
await deleteCampaign(params.id!, tenantId);
return redirect(params.tenant ? appPath({ tenantSlug: params.tenant, path: "email-marketing/campaigns", mode: "host-aware" }) : adminPath("email-marketing/campaigns", { mode: "host-aware" }));
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else if (action === "update") {
try {
await updateCampaign(params.id!, tenantId, {
name: form.get("name")?.toString(),
subject: form.get("subject")?.toString(),
htmlBody: form.get("htmlBody")?.toString(),
textBody: form.get("textBody")?.toString(),
// status: form.get("status")?.toString(),
});
return Response.json({ success: t("shared.saved") });
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else if (action === "send") {
try {
await EmailMarketingService.sendCampaign(item);
return Response.json({ success: t("shared.sent") }, { status: 200 });
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else if (action === "send-preview") {
try {
const email = form.get("email")?.toString() ?? "";
await EmailMarketingService.sendCampaignTest(item, email);
return Response.json({ success: t("shared.sent") }, { status: 200 });
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
};
}
@@ -0,0 +1,103 @@
// @vitest-environment node
import { LoaderFunctionArgs } from "react-router";
import { describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
getAllCampaigns: vi.fn(),
groupCampaigns: vi.fn(),
getAllEmailSenders: vi.fn(),
getTenantIdOrNull: vi.fn(),
requireAuth: vi.fn(),
t: vi.fn(),
}));
vi.mock("../db/campaigns.db.server", () => ({
getAllCampaigns: mocks.getAllCampaigns,
groupCampaigns: mocks.groupCampaigns,
}));
vi.mock("../db/emailSender", () => ({
getAllEmailSenders: mocks.getAllEmailSenders,
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdOrNull: mocks.getTenantIdOrNull,
}));
vi.mock("~/utils/loaders.middleware", () => ({
requireAuth: mocks.requireAuth,
}));
vi.mock("i18next", () => ({
t: mocks.t,
}));
function deferred<T>() {
let resolve: (value: T) => void = () => {};
const promise = new Promise<T>((promiseResolve) => {
resolve = promiseResolve;
});
return { promise, resolve };
}
async function flushPromises() {
await Promise.resolve();
await Promise.resolve();
}
describe("email marketing campaigns loader performance", () => {
it("starts independent campaign collections before awaiting any collection result", async () => {
vi.clearAllMocks();
mocks.requireAuth.mockResolvedValue(undefined);
mocks.getTenantIdOrNull.mockResolvedValue("tenant_1");
mocks.t.mockReturnValue("Campaigns | ToolCtrl");
const campaigns = deferred<unknown[]>();
const campaignGroups = deferred<{ status: string; _count: { _all: number } }[]>();
const emailSenders = deferred<unknown[]>();
const startedCalls: string[] = [];
mocks.getAllCampaigns.mockImplementation((tenantId: string | null, status: string | undefined) => {
startedCalls.push("campaigns");
expect(tenantId).toBe("tenant_1");
expect(status).toBe("draft");
return campaigns.promise;
});
mocks.groupCampaigns.mockImplementation((tenantId: string | null) => {
startedCalls.push("groups");
expect(tenantId).toBe("tenant_1");
return campaignGroups.promise;
});
mocks.getAllEmailSenders.mockImplementation((tenantId: string | null) => {
startedCalls.push("senders");
expect(tenantId).toBe("tenant_1");
return emailSenders.promise;
});
const { Campaigns_List } = await import("./Campaigns_List");
const loaderPromise = Campaigns_List.loader({
request: new Request("https://app.example.test/app/acme/email-marketing/campaigns?status=draft"),
params: { tenant: "acme" },
context: {},
} as LoaderFunctionArgs);
await flushPromises();
expect(startedCalls).toEqual(["campaigns", "groups", "senders"]);
campaigns.resolve([{ id: "campaign_1" }]);
campaignGroups.resolve([{ status: "draft", _count: { _all: 2 } }]);
emailSenders.resolve([{ id: "sender_1" }]);
await expect(loaderPromise).resolves.toEqual({
title: "Campaigns | ToolCtrl",
items: [{ id: "campaign_1" }],
groupByStatus: [{ status: "draft", count: 2 }],
emailSenders: [{ id: "sender_1" }],
});
expect(mocks.requireAuth).toHaveBeenCalledTimes(1);
expect(mocks.getTenantIdOrNull).toHaveBeenCalledTimes(1);
expect(mocks.t).toHaveBeenCalledWith("emailMarketing:meta.campaigns", { appName: process.env.APP_NAME });
});
});
@@ -0,0 +1,42 @@
import { LoaderFunctionArgs } from "react-router";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { CampaignWithDetails, getAllCampaigns, groupCampaigns } from "../db/campaigns.db.server";
import { EmailSenderWithoutApiKey, getAllEmailSenders } from "../db/emailSender";
import { requireAuth } from "~/utils/loaders.middleware";
import { t as i18nT } from "i18next";
export namespace Campaigns_List {
export type LoaderData = {
title: string;
items: CampaignWithDetails[];
groupByStatus: {
status: string;
count: number;
}[];
emailSenders: EmailSenderWithoutApiKey[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
const searchParams = new URL(request.url).searchParams;
const status = searchParams.get("status")?.toString();
const [items, campaignsCount, emailSenders] = await Promise.all([
getAllCampaigns(tenantId, status),
groupCampaigns(tenantId),
getAllEmailSenders(tenantId),
]);
const groupByStatus = campaignsCount.map((item) => {
return {
status: item.status,
count: item._count._all,
};
});
const data: LoaderData = {
title: i18nT("emailMarketing:meta.campaigns", { appName: process.env.APP_NAME }),
items,
groupByStatus,
emailSenders,
};
return data;
};
}
@@ -0,0 +1,110 @@
import { LoaderFunctionArgs, ActionFunction, redirect } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { EntityViewsApi } from "~/utils/api/.server/EntityViewsApi";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { EmailSenderWithoutApiKey, getAllEmailSenders, getEmailSender } from "../db/emailSender";
import EmailMarketingService from "../services/EmailMarketingService";
import { requireAuth } from "~/utils/loaders.middleware";
import { adminPath, appPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
import { requireEmailMarketingMutationAccess } from "./emailMarketingAccess.server";
import { t as i18nT } from "i18next";
export namespace Campaigns_New {
export type LoaderData = {
title: string;
contactsViews: EntityViewsApi.GetEntityViewsWithRows[];
emailSenders: EmailSenderWithoutApiKey[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
const emailSenders = await getAllEmailSenders(tenantId);
const data: LoaderData = {
title: i18nT("emailMarketing:meta.newCampaign", { appName: process.env.APP_NAME }),
emailSenders,
contactsViews: await EntityViewsApi.getAll({
entityName: "contact",
tenantId,
withDefault: false,
withRows: false,
}),
};
return data;
};
export type ActionData = {
error?: string;
success?: string;
};
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
await requireEmailMarketingMutationAccess({ request, params, tenantId });
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const email = form.get("email")?.toString() ?? "";
const senderId = form.get("senderId")?.toString() ?? "";
let subject = form.get("subject")?.toString() ?? "";
let htmlBody = form.get("htmlBody")?.toString() ?? "";
let textBody = form.get("textBody")?.toString() ?? "";
const sender = await getEmailSender(senderId, tenantId);
if (!sender) {
return Response.json({ error: t("emailMarketing:errors.invalidSender") }, { status: 400 });
}
if (!htmlBody && !textBody) {
return Response.json({ error: t("emailMarketing:errors.emailBodyRequired") }, { status: 400 });
}
if (action === "send-preview") {
try {
await EmailMarketingService.sendPreview({
from: { sender, tenantId },
email: { to: email, subject, htmlBody, textBody, track: true },
});
return Response.json({ success: t("shared.sent") }, { status: 200 });
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else if (action === "send-contact-preview") {
try {
const contactRowId = form.get("contactRowId")?.toString() ?? "";
await EmailMarketingService.sendContactPreview({
contactRowId,
from: { sender, tenantId },
email: { to: email, subject, htmlBody, textBody, track: true },
});
return Response.json({ success: t("shared.sent") }, { status: 200 });
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else if (action === "create") {
const name = form.get("name")?.toString() ?? "";
if (!name) {
return Response.json({ error: t("emailMarketing:errors.invalidName") }, { status: 400 });
}
const contactViewId = form.get("contactViewId")?.toString();
if (!contactViewId) {
return Response.json({ error: t("emailMarketing:errors.invalidRecipientList") }, { status: 400 });
}
try {
const campaign = await EmailMarketingService.createCampaignDraft({
name: form.get("name")?.toString() ?? "",
contactViewId,
from: { sender, tenantId },
email: { subject, htmlBody, textBody, track: true },
});
return redirect(
params.tenant
? appPath({ tenantSlug: params.tenant, path: `email-marketing/campaigns/${campaign.id}`, mode: "host-aware" })
: adminPath(`email-marketing/campaigns/${campaign.id}`, { mode: "host-aware" })
);
} catch (e: any) {
return Response.json({ error: e.message }, { status: 400 });
}
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
};
}
@@ -0,0 +1,23 @@
import { LoaderFunctionArgs } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import EmailMarketingService, { EmailMarketingSummaryDto } from "../services/EmailMarketingService";
import { requireAuth } from "~/utils/loaders.middleware";
export namespace EmailMarketing_Summary {
export type LoaderData = {
title: string;
summary: EmailMarketingSummaryDto;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
const data: LoaderData = {
title: `${t("emailMarketing:title")} | ${process.env.APP_NAME}`,
summary: await EmailMarketingService.getSummary(tenantId),
};
return data;
};
}
@@ -0,0 +1,73 @@
import { LoaderFunctionArgs } from "react-router";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import { getTranslations } from "~/locale/i18next.server";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { getAllCampaigns } from "../db/campaigns.db.server";
import { getAllEmailSenders } from "../db/emailSender";
import { OutboundEmailWithDetails, getAllOutboundEmails } from "../db/outboundEmails.db.server";
import { EntityWithDetails, getAllEntities } from "~/utils/db/entities/entities.db.server";
import { requireAuth } from "~/utils/loaders.middleware";
export namespace OutboundEmails_List {
export type LoaderData = {
items: OutboundEmailWithDetails[];
pagination: PaginationDto;
filterableProperties: FilterablePropertyDto[];
allEntities: EntityWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
const emailSenders = await getAllEmailSenders(tenantId);
const campaigns = await getAllCampaigns(tenantId);
const filterableProperties: FilterablePropertyDto[] = [
{
name: "senderId",
title: t("emailMarketing:activityFilters.sender"),
options: [
...emailSenders.map((i) => {
return {
value: i.id,
name: i.fromEmail + " (" + i.provider + ")",
};
}),
],
},
{
name: "campaignId",
title: t("emailMarketing:activityFilters.campaign"),
options: [
{ name: t("emailMarketing:activityFilters.preview"), value: "null" },
...campaigns.map((i) => {
return {
value: i.id,
name: i.name,
};
}),
],
},
];
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const urlSearchParams = new URL(request.url).searchParams;
const currentPagination = getPaginationFromCurrentUrl(urlSearchParams);
const fromSenderId = filters.properties.find((f) => f.name === "senderId")?.value ?? undefined;
const campaignId = filters.properties.find((f) => f.name === "campaignId")?.value;
const { items, pagination } = await getAllOutboundEmails(tenantId, {
where: {
fromSenderId,
campaignId: campaignId === "null" ? null : campaignId ?? undefined,
},
pagination: currentPagination,
});
const data: LoaderData = {
items,
pagination,
filterableProperties,
allEntities: await getAllEntities({ tenantId, active: true }),
};
return data;
};
}
@@ -0,0 +1,71 @@
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { EmailSenderWithoutApiKey, getEmailSenderWithoutApiKey, getEmailSender, updateEmailSender, deleteEmailSender } from "../db/emailSender";
import { requireAuth } from "~/utils/loaders.middleware";
import { adminPath, appPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
import { requireEmailMarketingMutationAccess } from "./emailMarketingAccess.server";
export namespace Senders_Edit {
export type LoaderData = {
item: EmailSenderWithoutApiKey;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
const item = await getEmailSenderWithoutApiKey(params.id!, tenantId);
if (!item) {
return redirect(params.tenant ? appPath({ tenantSlug: params.tenant, path: "email-marketing/senders", mode: "host-aware" }) : adminPath("email-marketing/senders", { mode: "host-aware" }));
}
const data: LoaderData = {
item,
};
return data;
};
export type ActionData = {
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
await requireEmailMarketingMutationAccess({ request, params, tenantId });
const existing = await getEmailSender(params.id ?? "", tenantId);
if (!existing) {
return badRequest({ error: t("shared.notFound") });
}
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "edit") {
try {
const provider = form.get("provider")?.toString() ?? "";
const stream = form.get("stream")?.toString() ?? "";
const fromEmail = form.get("fromEmail")?.toString() ?? "";
const fromName = form.get("fromName")?.toString() ?? "";
const replyToEmail = form.get("replyToEmail")?.toString() ?? "";
await updateEmailSender(existing.id, tenantId, {
provider,
stream,
fromEmail,
fromName,
replyToEmail,
});
return redirect(params.tenant ? appPath({ tenantSlug: params.tenant, path: "email-marketing/senders", mode: "host-aware" }) : adminPath("email-marketing/senders", { mode: "host-aware" }));
} catch (e: any) {
return badRequest({ error: e.message });
}
} else if (action === "delete") {
await deleteEmailSender(existing.id, tenantId);
return redirect(params.tenant ? appPath({ tenantSlug: params.tenant, path: "email-marketing/senders", mode: "host-aware" }) : adminPath("email-marketing/senders", { mode: "host-aware" }));
}
return badRequest({ error: t("shared.invalidForm") });
};
}
@@ -0,0 +1,87 @@
import { LoaderFunctionArgs, ActionFunction } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { EmailSenderWithoutApiKey, getAllEmailSenders, getEmailSender } from "../db/emailSender";
import { createOutboundEmailTest, findOutboundEmails, updateOutboundEmail } from "../db/outboundEmails.db.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { sendBroadcast } from "../services/EmailMarketingSenderService.server";
import { validateCSRFToken } from "~/utils/session.server";
import { requireEmailMarketingMutationAccess } from "./emailMarketingAccess.server";
export namespace Senders_List {
export type LoaderData = {
items: EmailSenderWithoutApiKey[];
hasSetWebhooks: boolean;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
const items = await getAllEmailSenders(tenantId);
const deliveredEmails = await findOutboundEmails(tenantId, {
where: {
deliveredAt: { not: null },
},
});
const data: LoaderData = {
items,
hasSetWebhooks: deliveredEmails.length > 0,
};
return data;
};
export type ActionData = {
error?: string;
success?: string;
};
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
await requireEmailMarketingMutationAccess({ request, params, tenantId });
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const email = form.get("email")?.toString() ?? "";
const senderId = form.get("senderId")?.toString() ?? "";
if (action === "send-test") {
const sender = await getEmailSender(senderId, tenantId);
if (!sender) {
return Response.json({ error: t("emailMarketing:errors.invalidSender") }, { status: 400 });
}
const outbountEmail = await createOutboundEmailTest({
tenantId,
email,
fromSenderId: senderId,
});
try {
await sendBroadcast({
sender,
to: email,
subject: t("emailMarketing:senders.testEmail.subject"),
htmlBody: getTestHtmlBody(t),
textBody: `${t("emailMarketing:defaults.body.testEmailWithLink")}: https://www.example.com.\n`,
track: true,
metadata: {
outboundEmailId: outbountEmail.id,
},
});
await updateOutboundEmail(outbountEmail.id, {
sentAt: new Date(),
});
return Response.json({ success: t("shared.sent") }, { status: 200 });
} catch (e: any) {
await updateOutboundEmail(outbountEmail.id, {
error: e.message,
});
return Response.json({ error: e.message }, { status: 400 });
}
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
};
}
function getTestHtmlBody(t: (key: string) => string) {
return `${t("emailMarketing:defaults.body.testEmailWithLink")}:
${t("emailMarketing:defaults.body.linkLabel")}: <a href="https://www.google.com">Google</a><br/>
`;
}
@@ -0,0 +1,64 @@
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { createEmailSender } from "../db/emailSender";
import { requireAuth } from "~/utils/loaders.middleware";
import { adminPath, appPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
import { requireEmailMarketingMutationAccess } from "./emailMarketingAccess.server";
export namespace Senders_New {
export type LoaderData = {
title: string;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const data: LoaderData = {
title: `${t("emailMarketing:senders.plural")} | ${process.env.APP_NAME}`,
};
return data;
};
export type ActionData = {
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
await requireEmailMarketingMutationAccess({ request, params, tenantId });
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "create") {
try {
const provider = form.get("provider")?.toString() ?? "";
const stream = form.get("stream")?.toString() ?? "";
const apiKey = form.get("apiKey")?.toString() ?? "";
const apiSecret = form.get("secretKey")?.toString() ?? "";
const fromEmail = form.get("fromEmail")?.toString() ?? "";
const fromName = form.get("fromName")?.toString() ?? "";
const replyToEmail = form.get("replyToEmail")?.toString() ?? "";
await createEmailSender({
tenantId,
provider,
stream,
apiKey,
apiSecret,
fromEmail,
fromName,
replyToEmail,
});
return redirect(params.tenant ? appPath({ tenantSlug: params.tenant, path: "email-marketing/senders", mode: "host-aware" }) : adminPath("email-marketing/senders", { mode: "host-aware" }));
} catch (e: any) {
return badRequest({ error: e.message });
}
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
}
@@ -0,0 +1,28 @@
import fs from "node:fs";
import path from "node:path";
import { describe, expect, test } from "vitest";
import { resolveRepoPath } from "~/utils/testing/repoPaths";
const appRoot = resolveRepoPath("apps/web/app");
const emailMarketingMutationHandlers = [
"modules/emailMarketing/routes/Campaigns_Edit.ts",
"modules/emailMarketing/routes/Campaigns_New.ts",
"modules/emailMarketing/routes/Senders_Edit.ts",
"modules/emailMarketing/routes/Senders_List.ts",
"modules/emailMarketing/routes/Senders_New.ts",
];
describe("email marketing route authorization boundary", () => {
test("requires tenant admin access and csrf before parsing mutating forms", () => {
for (const relativePath of emailMarketingMutationHandlers) {
const source = fs.readFileSync(path.join(appRoot, relativePath), "utf8");
expect(source.indexOf("await requireEmailMarketingMutationAccess({ request, params, tenantId })"), relativePath).toBeGreaterThanOrEqual(0);
expect(source.indexOf("await validateCSRFToken(request)"), relativePath).toBeGreaterThanOrEqual(0);
expect(source.indexOf("await requireEmailMarketingMutationAccess({ request, params, tenantId })"), relativePath).toBeLessThan(
source.indexOf("await request.formData()")
);
expect(source.indexOf("await validateCSRFToken(request)"), relativePath).toBeLessThan(source.indexOf("await request.formData()"));
}
});
});
@@ -0,0 +1,16 @@
import type { Params } from "react-router";
import { requireSuperUserOrAdmin } from "~/utils/loaders.middleware";
export async function requireEmailMarketingMutationAccess({
request,
params,
tenantId,
}: {
request: Request;
params: Params;
tenantId: string | null;
}) {
if (tenantId) {
await requireSuperUserOrAdmin({ request, params });
}
}