Skip to content

Email for professionals and teams

fix: restrict domain routing to authorized admins (#147)

Taruned045c616fbc
diff --git a/src/app/(admin)/routing/utils.ts b/src/app/(admin)/routing/utils.ts
index e7d16a3..e352d9c 100644
--- a/src/app/(admin)/routing/utils.ts
+++ b/src/app/(admin)/routing/utils.ts
@@ -2,7 +2,7 @@ import { authFetch } from "@/lib/auth/client";
import type { AdminRoutingDomainsResponse } from "./types";
export async function fetchAdminRoutingDomains(): Promise<AdminRoutingDomainsResponse> {
- const response = await authFetch("/api/domains");
+ const response = await authFetch("/api/routing-rules/domain?list=true");
const data = (await response.json()) as AdminRoutingDomainsResponse & { error?: string };
if (!response.ok) throw new Error(data.error ?? "Unable to load domains");
return { domains: data.domains ?? [] };
diff --git a/src/app/api/routing-rules/[id]/route.ts b/src/app/api/routing-rules/[id]/route.ts
index 0a50585..32aa979 100644
--- a/src/app/api/routing-rules/[id]/route.ts
+++ b/src/app/api/routing-rules/[id]/route.ts
@@ -19,7 +19,7 @@ export async function PATCH(request: Request, { params }: RoutingRuleRouteParams
const db = getDb(env);
const [rule] = await db.select().from(routingRules).where(eq(routingRules.id, id)).limit(1);
- if (!rule?.mailboxId || rule.mailboxId !== parsed.data.mailboxId) {
+ if (rule?.scope !== "mailbox" || !rule.mailboxId || rule.mailboxId !== parsed.data.mailboxId) {
return NextResponse.json({ error: "Rule not found" }, { status: 404 });
}
const access = await getMailboxAccessLevel(db, user, rule.mailboxId);
@@ -67,7 +67,7 @@ export async function DELETE(request: Request, { params }: RoutingRuleRouteParam
const user = await requireUser(env, request);
const db = getDb(env);
const [rule] = await db.select().from(routingRules).where(eq(routingRules.id, id)).limit(1);
- if (!rule?.mailboxId) {
+ if (rule?.scope !== "mailbox" || !rule.mailboxId) {
return NextResponse.json({ error: "Rule not found" }, { status: 404 });
}
const access = await getMailboxAccessLevel(db, user, rule.mailboxId);
diff --git a/src/app/api/routing-rules/domain/[id]/route.ts b/src/app/api/routing-rules/domain/[id]/route.ts
index 3312968..5ffe356 100644
--- a/src/app/api/routing-rules/domain/[id]/route.ts
+++ b/src/app/api/routing-rules/domain/[id]/route.ts
@@ -6,19 +6,19 @@ import { requireSessionUser } from "@/lib/api/auth";
import { getEnv } from "@/lib/cloudflare";
import { domainRoutingRuleSchema } from "@/lib/validators";
import {
- assertRuleMailbox,
assertAdminRuleMailbox,
getAdminDomain,
- getManagedDomainMailbox,
toRuleColumns,
} from "@/lib/domains/routing-rules";
import type { DomainRoutingRuleRouteParams } from "./types";
+import { hasValidSessionMutationOrigin } from "@/lib/auth/origin";
/** Loads a domain-scope rule the caller is allowed to administer. */
async function loadRule(request: Request, id: string) {
const env = getEnv();
const auth = await requireSessionUser(env, request);
if (auth.error) return { error: auth.error } as const;
+ if (!hasValidSessionMutationOrigin(request)) return { error: NextResponse.json({ error: "Invalid origin" }, { status: 403 }) } as const;
const user = auth.user;
const db = getDb(env);
const [rule] = await db
@@ -30,10 +30,9 @@ async function loadRule(request: Request, id: string) {
return { error: NextResponse.json({ error: "Rule not found" }, { status: 404 }) } as const;
}
- const mailboxId = new URL(request.url).searchParams.get("mailboxId");
- const adminDomain = !mailboxId ? await getAdminDomain(db, user, rule.domainId) : null;
- if (!adminDomain && (!mailboxId || !(await getManagedDomainMailbox(db, user, mailboxId, rule.domainId)))) {
- return { error: NextResponse.json({ error: "Domain or mailbox access is required" }, { status: 403 }) } as const;
+ const adminDomain = await getAdminDomain(db, user, rule.domainId);
+ if (!adminDomain) {
+ return { error: NextResponse.json({ error: "Domain management permission is required" }, { status: 403 }) } as const;
}
return { env, db, user, rule, adminDomain, error: null } as const;
@@ -52,9 +51,7 @@ export async function PATCH(request: Request, { params }: DomainRoutingRuleRoute
}
const destinationAllowed = parsed.data.mailboxId
- ? loaded.adminDomain
- ? await assertAdminRuleMailbox(loaded.db, parsed.data.mailboxId, loaded.rule.domainId)
- : await assertRuleMailbox(loaded.db, loaded.user, parsed.data.mailboxId, loaded.rule.domainId)
+ ? await assertAdminRuleMailbox(loaded.db, parsed.data.mailboxId, loaded.rule.domainId)
: true;
if (!destinationAllowed) {
return NextResponse.json({ error: "Mailbox access is required for the destination" }, { status: 403 });
diff --git a/src/app/api/routing-rules/domain/route.ts b/src/app/api/routing-rules/domain/route.ts
index 20b99dc..32cb989 100644
--- a/src/app/api/routing-rules/domain/route.ts
+++ b/src/app/api/routing-rules/domain/route.ts
@@ -6,15 +6,14 @@ import { getEnv } from "@/lib/cloudflare";
import { newId } from "@/lib/ids";
import { domainRoutingRuleSchema } from "@/lib/validators";
import {
- assertRuleMailbox,
assertAdminRuleMailbox,
getAdminDomain,
- getManagedDomainMailbox,
listAdminDomainMailboxes,
- listManagedDomainMailboxes,
+ listAdminRoutingDomains,
listDomainRules,
toRuleColumns,
} from "@/lib/domains/routing-rules";
+import { hasValidSessionMutationOrigin } from "@/lib/auth/origin";
export async function GET(request: Request) {
const env = getEnv();
@@ -22,23 +21,25 @@ export async function GET(request: Request) {
if (auth.error) return auth.error;
const user = auth.user;
const searchParams = new URL(request.url).searchParams;
+ const db = getDb(env);
+ if (searchParams.get("list") === "true") {
+ const domains = await listAdminRoutingDomains(db, user);
+ if (!domains) return NextResponse.json({ error: "Domain management permission is required" }, { status: 403 });
+ return NextResponse.json({ domains });
+ }
const domainId = searchParams.get("domainId");
- const mailboxId = searchParams.get("mailboxId");
if (!domainId) {
return NextResponse.json({ error: "domainId is required" }, { status: 400 });
}
- const db = getDb(env);
- const adminDomain = !mailboxId ? await getAdminDomain(db, user, domainId) : null;
- if (!adminDomain && (!mailboxId || !(await getManagedDomainMailbox(db, user, mailboxId, domainId)))) {
- return NextResponse.json({ error: "Domain or mailbox access is required" }, { status: 403 });
+ const adminDomain = await getAdminDomain(db, user, domainId);
+ if (!adminDomain) {
+ return NextResponse.json({ error: "Domain management permission is required" }, { status: 403 });
}
return NextResponse.json({
rules: await listDomainRules(db, domainId),
- mailboxes: adminDomain
- ? await listAdminDomainMailboxes(db, domainId)
- : await listManagedDomainMailboxes(db, user, domainId),
+ mailboxes: await listAdminDomainMailboxes(db, domainId),
});
}
@@ -47,22 +48,20 @@ export async function POST(request: Request) {
const auth = await requireSessionUser(env, request);
if (auth.error) return auth.error;
const user = auth.user;
+ if (!hasValidSessionMutationOrigin(request)) return NextResponse.json({ error: "Invalid origin" }, { status: 403 });
const parsed = domainRoutingRuleSchema.safeParse(await request.json());
if (!parsed.success) {
return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
}
const db = getDb(env);
- const mailboxId = new URL(request.url).searchParams.get("mailboxId");
- const adminDomain = !mailboxId ? await getAdminDomain(db, user, parsed.data.domainId) : null;
- if (!adminDomain && (!mailboxId || !(await getManagedDomainMailbox(db, user, mailboxId, parsed.data.domainId)))) {
- return NextResponse.json({ error: "Domain or mailbox access is required" }, { status: 403 });
+ const adminDomain = await getAdminDomain(db, user, parsed.data.domainId);
+ if (!adminDomain) {
+ return NextResponse.json({ error: "Domain management permission is required" }, { status: 403 });
}
const destinationAllowed = parsed.data.mailboxId
- ? adminDomain
- ? await assertAdminRuleMailbox(db, parsed.data.mailboxId, parsed.data.domainId)
- : await assertRuleMailbox(db, user, parsed.data.mailboxId, parsed.data.domainId)
+ ? await assertAdminRuleMailbox(db, parsed.data.mailboxId, parsed.data.domainId)
: true;
if (!destinationAllowed) {
return NextResponse.json({ error: "Mailbox access is required for the destination" }, { status: 403 });
diff --git a/src/components/admin-nav.tsx b/src/components/admin-nav.tsx
index 6d28cbd..8c1b27d 100644
--- a/src/components/admin-nav.tsx
+++ b/src/components/admin-nav.tsx
@@ -47,7 +47,7 @@ const sections: { id?: string; labelKey?: TranslationKey; links: AdminNavLink[]
links: [
{ href: "/mailboxes", labelKey: "admin.nav.mailboxes", icon: Mail },
{ href: "/domains", labelKey: "admin.nav.domains", icon: Globe2, permission: "domains" },
- { href: "/routing", labelKey: "admin.nav.routing", icon: Route },
+ { href: "/routing", labelKey: "admin.nav.routing", icon: Route, permission: "domains" },
{ href: "/webhooks", labelKey: "admin.nav.webhooks", icon: Webhook, permission: "primary" },
],
},
diff --git a/src/components/settings/domain-routing/domain-routing.tsx b/src/components/settings/domain-routing/domain-routing.tsx
index a253c19..016cd26 100644
--- a/src/components/settings/domain-routing/domain-routing.tsx
+++ b/src/components/settings/domain-routing/domain-routing.tsx
@@ -21,6 +21,8 @@ import { Switch } from "@/components/ui/switch";
import { Tooltip } from "@/components/ui/tooltip";
import { CardGridSkeleton } from "@/components/page-skeletons";
import { useSelectedMailbox } from "@/components/mailbox-provider";
+import { useCurrentUser } from "@/hooks/use-current-user";
+import { canManageDomains } from "@/lib/auth/admin";
import type { DomainRoutingProps, DomainRule, DomainRuleInput } from "./types";
import {
ACTION_LABELS,
@@ -46,6 +48,7 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
const { t } = useLanguage();
const qc = useQueryClient();
const { selectedMailbox, isLoading: isMailboxLoading } = useSelectedMailbox();
+ const currentUser = useCurrentUser();
const [dialogOpen, setDialogOpen] = useState(false);
const [editing, setEditing] = useState<DomainRule | null>(null);
const [form, setForm] = useState<DomainRuleInput>(emptyRuleInput(""));
@@ -53,14 +56,13 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
const domainId = domain?.id ?? selectedMailbox?.domainId ?? "";
const mailboxId = selectedMailbox?.id ?? "";
- const mailboxAccessId = domain ? undefined : mailboxId;
- const canManage = !!domain || selectedMailbox?.permission === "full_access";
- const rulesQueryKey = ["domain-rules", domainId, mailboxAccessId ?? "admin"] as const;
+ const canManage = !!currentUser && canManageDomains(currentUser);
+ const rulesQueryKey = ["domain-rules", domainId] as const;
const rules = useQuery({
queryKey: rulesQueryKey,
- enabled: !!domainId && (!!domain || !!mailboxId) && canManage,
- queryFn: () => fetchDomainRules(domainId, mailboxAccessId),
+ enabled: !!domainId && canManage,
+ queryFn: () => fetchDomainRules(domainId),
});
const hostname = domain?.hostname ?? selectedMailbox?.hostname ?? "";
@@ -70,8 +72,8 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
mutationFn: () => {
const payload: DomainRuleInput = { ...form, domainId };
return editing
- ? updateDomainRule(editing.id, payload, mailboxAccessId)
- : createDomainRule(payload, mailboxAccessId);
+ ? updateDomainRule(editing.id, payload)
+ : createDomainRule(payload);
},
onSuccess: () => {
setDialogOpen(false);
@@ -83,13 +85,13 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
});
const remove = useMutation({
- mutationFn: (id: string) => deleteDomainRule(id, mailboxAccessId),
+ mutationFn: (id: string) => deleteDomainRule(id),
onSuccess: () => qc.invalidateQueries({ queryKey: rulesQueryKey }),
});
const toggle = useMutation({
mutationFn: (rule: DomainRule) =>
- updateDomainRule(rule.id, { ...ruleToInput(rule), enabled: !rule.enabled }, mailboxAccessId),
+ updateDomainRule(rule.id, { ...ruleToInput(rule), enabled: !rule.enabled }),
onSuccess: () => qc.invalidateQueries({ queryKey: rulesQueryKey }),
});
@@ -109,6 +111,7 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
const blockRules = (rules.data?.rules ?? []).filter((r) => r.action === "reject");
const fallbackRules = (rules.data?.rules ?? []).filter((r) => r.action !== "reject");
+ if (!canManage) return null;
return (
<div className="space-y-6">
@@ -125,7 +128,7 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
<p className="mt-1 text-sm text-neutral-500">{t("routing.rulesFor", { host: hostname || t("routing.selectInbox") })}</p>
</div>
<div className="flex items-end gap-2">
- <Button onClick={openCreate} disabled={!domainId || (!domain && !mailboxId) || !canManage}>
+ <Button onClick={openCreate} disabled={!domainId}>
<Plus className="h-4 w-4" /> {t("routing.addRoute")}
</Button>
</div>
@@ -139,12 +142,6 @@ export function DomainRouting({ domain }: DomainRoutingProps = {}) {
{t("routing.selectInboxFirst")}
</CardContent>
</Card>
- ) : !canManage ? (
- <Card>
- <CardContent className="pt-6 text-sm text-neutral-500">
- {t("routing.needFullAccess")}
- </CardContent>
- </Card>
) : (
<div className="space-y-1 overflow-hidden rounded-3xl">
<RuleSection
diff --git a/src/hooks/use-current-user.ts b/src/hooks/use-current-user.ts
index d5213d3..7689cfa 100644
--- a/src/hooks/use-current-user.ts
+++ b/src/hooks/use-current-user.ts
@@ -17,8 +17,10 @@ export type CurrentUser = {
let cachedUser: CurrentUser | null = null;
let inflight: Promise<CurrentUser | null> | null = null;
+let generation = 0;
export function clearCurrentUserCache(): void {
+ generation += 1;
cachedUser = null;
inflight = null;
}
@@ -26,16 +28,19 @@ export function clearCurrentUserCache(): void {
export function fetchCurrentUser(): Promise<CurrentUser | null> {
if (cachedUser) return Promise.resolve(cachedUser);
if (!inflight) {
- inflight = authFetch("/api/auth/me", { redirectOnUnauthorized: false })
+ const requestGeneration = generation;
+ const request = authFetch("/api/auth/me", { redirectOnUnauthorized: false })
.then((response) => (response.ok ? response.json() : null))
.then((data) => {
+ if (requestGeneration !== generation) return null;
cachedUser = (data as { user?: CurrentUser } | null)?.user ?? null;
return cachedUser;
})
.catch(() => null)
.finally(() => {
- inflight = null;
+ if (inflight === request) inflight = null;
});
+ inflight = request;
}
return inflight;
}
@@ -46,8 +51,9 @@ export function useCurrentUser(): CurrentUser | null {
useEffect(() => {
let active = true;
+ const requestGeneration = generation;
void fetchCurrentUser().then((next) => {
- if (active) setUser(next);
+ if (active && requestGeneration === generation) setUser(next);
});
return () => {
active = false;
@@ -58,6 +64,7 @@ export function useCurrentUser(): CurrentUser | null {
useEffect(() => {
function onSessionChanged() {
clearCurrentUserCache();
+ setUser(null);
setReloadKey((key) => key + 1);
}
window.addEventListener(AUTH_SESSION_CHANGED_EVENT, onSessionChanged);
diff --git a/src/lib/domains/routing-rules.ts b/src/lib/domains/routing-rules.ts
index a44240f..fcfe029 100644
--- a/src/lib/domains/routing-rules.ts
+++ b/src/lib/domains/routing-rules.ts
@@ -1,8 +1,9 @@
-import { and, asc, desc, eq } from "drizzle-orm";
+import { and, asc, desc, eq, inArray } from "drizzle-orm";
import type { AppDatabase } from "@/db";
import { domains, mailboxes, routingRules } from "@/db/schema";
import type { SessionUser } from "@/lib/auth/types";
import { getMailboxAccessLevel, listAccessibleMailboxes } from "@/lib/mailboxes/access";
+import { canManageDomains } from "@/lib/auth/admin";
export type DomainRuleInput = {
domainId: string;
@@ -50,17 +51,26 @@ export async function listManagedDomainMailboxes(
.sort((a, b) => a.localPart.localeCompare(b.localPart));
}
+export async function listAdminRoutingDomains(
+ db: AppDatabase,
+ user: Pick<SessionUser, "id" | "role" | "isPrimaryAdmin" | "canManageDomains" | "createdByUserId">,
+) {
+ if (!canManageDomains(user)) return null;
+ const ownerIds = !user.isPrimaryAdmin && user.createdByUserId ? [user.id, user.createdByUserId] : [user.id];
+ return db.select().from(domains).where(inArray(domains.userId, ownerIds)).orderBy(asc(domains.hostname));
+}
+
export async function getAdminDomain(
db: AppDatabase,
- user: Pick<SessionUser, "id" | "role" | "canManageMailboxes" | "createdByUserId">,
+ user: Pick<SessionUser, "id" | "role" | "isPrimaryAdmin" | "canManageDomains" | "createdByUserId">,
domainId: string,
) {
- if (user.role !== "admin") return null;
- const ownerId = user.canManageMailboxes && user.createdByUserId ? user.createdByUserId : user.id;
+ if (!canManageDomains(user)) return null;
+ const ownerIds = !user.isPrimaryAdmin && user.createdByUserId ? [user.id, user.createdByUserId] : [user.id];
const [domain] = await db
.select()
.from(domains)
- .where(and(eq(domains.id, domainId), eq(domains.userId, ownerId)))
+ .where(and(eq(domains.id, domainId), inArray(domains.userId, ownerIds)))
.limit(1);
return domain ?? null;
}
diff --git a/tests/current-user-permission-reset.test.mjs b/tests/current-user-permission-reset.test.mjs
new file mode 100644
index 0000000..f4d5685
--- /dev/null
+++ b/tests/current-user-permission-reset.test.mjs
@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import test, { after } from "node:test";
+import { build } from "esbuild";
+import { JSDOM } from "jsdom";
+
+const project = join(dirname(fileURLToPath(import.meta.url)), "..");
+const directory = mkdtempSync(join(project, "node_modules", "permission-user-test-"));
+after(() => rmSync(directory, { recursive: true, force: true }));
+await build({ entryPoints: [join(project, "src/hooks/use-current-user.ts")], outfile: join(directory, "user.mjs"), bundle: true, platform: "node", format: "esm", packages: "external", plugins: [{ name: "test-auth", setup(builder) { builder.onResolve({ filter: /^@\/lib\/auth\/client$/ }, () => ({ path: "auth", namespace: "mock" })); builder.onLoad({ filter: /.*/, namespace: "mock" }, () => ({ contents: "export const AUTH_SESSION_CHANGED_EVENT='permission-session-changed';export function authFetch(){return globalThis.fetchUserResponse()}", loader: "js" })); } }], logLevel: "silent" });
+const { fetchCurrentUser, clearCurrentUserCache, useCurrentUser } = await import(pathToFileURL(join(directory, "user.mjs")).href);
+const response = role => ({ ok: true, json: async () => ({ user: { id: role, role, isPrimaryAdmin: role === "admin", canManageDomains: role === "admin" } }) });
+
+test("an old account response cannot repopulate permissions or clear the new inflight request", async () => {
+ clearCurrentUserCache(); let oldResolve, newResolve;
+ globalThis.fetchUserResponse = () => new Promise(resolve => { oldResolve = resolve; });
+ const oldRequest = fetchCurrentUser();
+ clearCurrentUserCache();
+ globalThis.fetchUserResponse = () => new Promise(resolve => { newResolve = resolve; });
+ const newRequest = fetchCurrentUser();
+ oldResolve(response("admin")); assert.equal(await oldRequest, null);
+ assert.equal(fetchCurrentUser(), newRequest);
+ newResolve(response("user")); assert.equal((await newRequest).role, "user");
+ assert.equal((await fetchCurrentUser()).canManageDomains, false);
+});
+test("account switch immediately hides old permission UI until the new account resolves", async () => {
+ const dom = new JSDOM("<!doctype html><div id='root'></div>");
+ globalThis.window = dom.window; globalThis.document = dom.window.document; globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+ const { createElement, act } = await import("react"); const { createRoot } = await import("react-dom/client");
+ clearCurrentUserCache(); globalThis.fetchUserResponse = async () => response("admin"); await fetchCurrentUser();
+ function Fixture() { const user = useCurrentUser(); return createElement("div", null, user?.canManageDomains ? "domain admin" : "no domain permission"); }
+ const root = createRoot(document.getElementById("root")); await act(async () => root.render(createElement(Fixture)));
+ assert.equal(document.body.textContent, "domain admin"); let resolve;
+ globalThis.fetchUserResponse = () => new Promise(done => { resolve = done; });
+ await act(async () => window.dispatchEvent(new dom.window.Event("permission-session-changed")));
+ assert.equal(document.body.textContent, "no domain permission");
+ await act(async () => resolve(response("user"))); assert.equal(document.body.textContent, "no domain permission");
+ await act(async () => root.unmount()); dom.window.close(); delete globalThis.window; delete globalThis.document; delete globalThis.IS_REACT_ACT_ENVIRONMENT; delete globalThis.fetchUserResponse;
+});
diff --git a/tests/domain-routing-permissions.test.mjs b/tests/domain-routing-permissions.test.mjs
new file mode 100644
index 0000000..2b7d300
--- /dev/null
+++ b/tests/domain-routing-permissions.test.mjs
@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import test, { after } from "node:test";
+import { DatabaseSync } from "node:sqlite";
+import { drizzle } from "drizzle-orm/sqlite-proxy";
+import { getTableConfig } from "drizzle-orm/sqlite-core";
+import { build } from "esbuild";
+
+const project = join(dirname(fileURLToPath(import.meta.url)), "..");
+const temporary = mkdtempSync(join(project, "node_modules", "permission-test-"));
+after(() => rmSync(temporary, { recursive: true, force: true }));
+const mocks = {
+ "next/server": "export const NextResponse={json:(data,init)=>Response.json(data,init)};",
+ "@/db": "export function getDb(){return globalThis.permissionDb}",
+ "@/lib/cloudflare": "export function getEnv(){return {}}",
+ "@/lib/auth/cookies": "export async function requireUser(){return globalThis.permissionUser}",
+ "@/lib/api/auth": "export async function requireSessionUser(){return globalThis.permissionUser?{user:globalThis.permissionUser,error:null}:{user:null,error:Response.json({error:'Unauthorized'},{status:401})}}",
+ "@/lib/mailboxes/access": "export async function getMailboxAccessLevel(db,user,id){return globalThis.managedMailboxes.includes(id)?{canManage:true,mailbox:{id,domainId:'d-owner'}}:null} export async function listAccessibleMailboxes(){return []}",
+};
+await build({ stdin: { contents: `export * as domain from './src/app/api/routing-rules/domain/route';export * as domainItem from './src/app/api/routing-rules/domain/[id]/route';export * as mailbox from './src/app/api/routing-rules/route';export * as mailboxItem from './src/app/api/routing-rules/[id]/route';export * as schema from './src/db/schema';export {emptyRuleInput} from './src/components/settings/domain-routing/utils';`, resolveDir: project, loader: "ts" }, outfile: join(temporary, "routes.mjs"), bundle: true, platform: "node", format: "esm", packages: "external", alias: { "@": join(project, "src") }, plugins: [{ name: "test-auth-and-db", setup(builder) { builder.onResolve({ filter: /^(next\/server|@\/db|@\/lib\/(cloudflare|auth\/cookies|api\/auth|mailboxes\/access))$/ }, args => ({ path: args.path, namespace: "mock" })); builder.onLoad({ filter: /.*/, namespace: "mock" }, args => ({ contents: mocks[args.path], loader: "js" })); } }], logLevel: "silent" });
+const { domain, domainItem, mailbox, mailboxItem, schema, emptyRuleInput } = await import(pathToFileURL(join(temporary, "routes.mjs")).href);
+const quote = value => `"${value.replaceAll('"', '""')}"`;
+const owner = { id: "owner", role: "admin", isPrimaryAdmin: true, canManageDomains: false };
+const manager = { id: "manager", role: "admin", isPrimaryAdmin: false, canManageDomains: true, createdByUserId: "owner" };
+const ordinary = { id: "user", role: "user", isPrimaryAdmin: false, canManageDomains: false };
+let sqlite;
+function setup(user) {
+ sqlite?.close(); sqlite = new DatabaseSync(":memory:");
+ for (const value of Object.values(schema)) { let table; try { table = getTableConfig(value); } catch { continue; } sqlite.exec(`CREATE TABLE ${quote(table.name)} (${table.columns.map(column => `${quote(column.name)} ${column.getSQLType()}`).join(",")})`); }
+ globalThis.permissionDb = drizzle(async (sql, params, method) => { const query = sqlite.prepare(sql); if (method === "run") { query.run(...params); return { rows: [] }; } query.setReturnArrays(true); return { rows: query.all(...params) }; });
+ globalThis.permissionUser = user; globalThis.managedMailboxes = ["m-user", "m-shared"];
+ sqlite.exec("INSERT INTO domains(id,user_id,hostname) VALUES ('d-owner','owner','example.test'),('d-other','other','other.test'),('d-self','manager','self.test'); INSERT INTO mailboxes(id,user_id,domain_id,local_part,disabled) VALUES ('m-user','user','d-owner','user',0),('m-shared','owner','d-owner','team',0),('m-other','other','d-other','other',0); INSERT INTO routing_rules(id,user_id,domain_id,scope,mailbox_id,match_field,match_operator,match_value,action,enabled,keep_copy,priority,created_at) VALUES ('r-domain','owner','d-owner','domain','m-user','recipient','exact','*','store',1,0,100,0),('r-mailbox','user','d-owner','mailbox','m-user','sender','contains','news','spam',1,0,10,0),('r-other','other','d-other','domain','m-other','recipient','exact','*','store',1,0,100,0);");
+}
+after(() => { sqlite?.close(); delete globalThis.permissionDb; delete globalThis.permissionUser; delete globalThis.managedMailboxes; });
+const input = overrides => ({ ...emptyRuleInput("d-owner"), matchValue: "*", mailboxId: "m-user", ...overrides });
+const request = (path, method = "GET", body, origin = "https://mail.test") => new Request(`https://mail.test${path}`, { method, headers: { Origin: origin, "Content-Type": "application/json" }, ...(body ? { body: JSON.stringify(body) } : {}) });
+const context = id => ({ params: Promise.resolve({ id }) });
+
+test("mailbox owners, full-access sharers and mailbox-only admins cannot use any domain rule API", async () => {
+ for (const user of [ordinary, { ...ordinary, id: "shared-user" }, { id: "mailbox-admin", role: "admin", isPrimaryAdmin: false, canManageMailboxes: true, canManageDomains: false, createdByUserId: "owner" }, { ...ordinary, canManageDomains: true }]) {
+ setup(user);
+ assert.equal((await domain.GET(request("/api/routing-rules/domain?list=true"))).status, 403);
+ for (const suffix of ["", "&mailboxId=m-user", "&mailboxId=m-shared"]) {
+ assert.equal((await domain.GET(request(`/api/routing-rules/domain?domainId=d-owner${suffix}`))).status, 403);
+ assert.equal((await domain.POST(request(`/api/routing-rules/domain?x=1${suffix}`, "POST", input()))).status, 403);
+ assert.equal((await domainItem.PATCH(request(`/api/routing-rules/domain/r-domain?x=1${suffix}`, "PATCH", input()), context("r-domain"))).status, 403);
+ assert.equal((await domainItem.DELETE(request(`/api/routing-rules/domain/r-domain?x=1${suffix}`, "DELETE"), context("r-domain"))).status, 403);
+ }
+ assert.equal(sqlite.prepare("SELECT action FROM routing_rules WHERE id='r-domain'").get().action, "store");
+ }
+});
+test("primary/domain admins retain CRUD, same-domain destinations and owner isolation", async () => {
+ for (const user of [owner, manager]) {
+ setup(user);
+ const listed = await domain.GET(request("/api/routing-rules/domain?list=true"));
+ assert.equal(listed.status, 200);
+ assert.deepEqual((await listed.json()).domains.map(item => item.id).sort(), user === owner ? ["d-owner"] : ["d-owner", "d-self"]);
+ assert.equal((await domain.GET(request("/api/routing-rules/domain?domainId=d-owner&mailboxId=m-user"))).status, 200);
+ assert.equal((await domain.POST(request("/api/routing-rules/domain", "POST", input()))).status, 200);
+ assert.equal((await domainItem.PATCH(request("/api/routing-rules/domain/r-domain", "PATCH", input({ action: "reject", mailboxId: null })), context("r-domain"))).status, 200);
+ assert.equal((await domain.GET(request("/api/routing-rules/domain?domainId=d-other"))).status, 403);
+ assert.equal((await domain.POST(request("/api/routing-rules/domain", "POST", input({ mailboxId: "m-other" })))).status, 403);
+ assert.equal((await domainItem.PATCH(request("/api/routing-rules/domain/r-domain", "PATCH", input({ domainId: "d-other", mailboxId: "m-other" })), context("r-domain"))).status, 403);
+ assert.equal((await domainItem.DELETE(request("/api/routing-rules/domain/r-other", "DELETE"), context("r-other"))).status, 403);
+ assert.equal((await domainItem.DELETE(request("/api/routing-rules/domain/r-domain", "DELETE"), context("r-domain"))).status, 200);
+ }
+ setup(manager); assert.equal((await domain.GET(request("/api/routing-rules/domain?domainId=d-self"))).status, 200);
+});
+test("mailbox routes cannot modify domain rules even with the destination inbox permission", async () => {
+ setup(ordinary);
+ const payload = { mailboxId: "m-user", matchField: "email", matchOperator: "contains", matchValue: "news", destination: "spam", priority: 100 };
+ assert.equal((await mailboxItem.PATCH(request("/api/routing-rules/r-domain", "PATCH", payload), context("r-domain"))).status, 404);
+ assert.equal((await mailboxItem.DELETE(request("/api/routing-rules/r-domain", "DELETE"), context("r-domain"))).status, 404);
+ const listed = await (await mailbox.GET(request("/api/routing-rules?mailboxId=m-user"))).json(); assert.deepEqual(listed.rules.map(rule => rule.id), ["r-mailbox"]);
+ assert.equal((await mailbox.POST(request("/api/routing-rules", "POST", payload))).status, 200);
+ assert.equal((await mailboxItem.PATCH(request("/api/routing-rules/r-mailbox", "PATCH", payload), context("r-mailbox"))).status, 200);
+ assert.equal((await mailboxItem.DELETE(request("/api/routing-rules/r-mailbox", "DELETE"), context("r-mailbox"))).status, 200);
+});
+test("cross-origin domain mutations and unauthenticated callers are denied", async () => {
+ setup(owner);
+ assert.equal((await domain.POST(request("/api/routing-rules/domain", "POST", input(), "https://evil.test"))).status, 403);
+ assert.equal((await domainItem.PATCH(request("/api/routing-rules/domain/r-domain", "PATCH", input(), "https://evil.test"), context("r-domain"))).status, 403);
+ assert.equal((await domainItem.DELETE(request("/api/routing-rules/domain/r-domain", "DELETE", undefined, "https://evil.test"), context("r-domain"))).status, 403);
+ globalThis.permissionUser = null; assert.equal((await domain.GET(request("/api/routing-rules/domain?domainId=d-owner"))).status, 401);
+});