Skip to content

Email for professionals and teams

Scope domain routing to inbox access

Hieu Nguyen (Jack)c8ff11c080a1
diff --git a/src/app/api/routing-rules/domain/[id]/route.ts b/src/app/api/routing-rules/domain/[id]/route.ts
index e6535d3..1c15df0 100644
--- a/src/app/api/routing-rules/domain/[id]/route.ts
+++ b/src/app/api/routing-rules/domain/[id]/route.ts
@@ -2,14 +2,12 @@ import { and, eq } from "drizzle-orm";
import { NextResponse } from "next/server";
import { getDb } from "@/db";
import { routingRules } from "@/db/schema";
-import { assertAdmin } from "@/lib/auth/admin";
import { requireSessionUser } from "@/lib/api/auth";
import { getEnv } from "@/lib/cloudflare";
import { domainRoutingRuleSchema } from "@/lib/validators";
import {
assertRuleMailbox,
- getDomainOwnerId,
- getOwnedDomain,
+ getManagedDomainMailbox,
toRuleColumns,
} from "@/lib/domains/routing-rules";
import type { DomainRoutingRuleRouteParams } from "./types";
@@ -20,12 +18,6 @@ async function loadRule(request: Request, id: string) {
const auth = await requireSessionUser(env, request);
if (auth.error) return { error: auth.error } as const;
const user = auth.user;
- try {
- assertAdmin(user);
- } catch {
- return { error: NextResponse.json({ error: "Forbidden" }, { status: 403 }) } as const;
- }
-
const db = getDb(env);
const [rule] = await db
.select()
@@ -36,12 +28,12 @@ async function loadRule(request: Request, id: string) {
return { error: NextResponse.json({ error: "Rule not found" }, { status: 404 }) } as const;
}
- const domain = await getOwnedDomain(db, getDomainOwnerId(user), rule.domainId);
- if (!domain) {
- return { error: NextResponse.json({ error: "Rule not found" }, { status: 404 }) } as const;
+ const mailboxId = new URL(request.url).searchParams.get("mailboxId");
+ if (!mailboxId || !(await getManagedDomainMailbox(db, user, mailboxId, rule.domainId))) {
+ return { error: NextResponse.json({ error: "Mailbox access is required" }, { status: 403 }) } as const;
}
- return { env, db, user, rule, domain, error: null } as const;
+ return { env, db, user, rule, error: null } as const;
}
export async function PATCH(request: Request, { params }: DomainRoutingRuleRouteParams) {
@@ -56,8 +48,8 @@ export async function PATCH(request: Request, { params }: DomainRoutingRuleRoute
return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
}
- if (parsed.data.mailboxId && !(await assertRuleMailbox(loaded.db, parsed.data.mailboxId, loaded.domain.id))) {
- return NextResponse.json({ error: "Mailbox not found on this domain" }, { status: 404 });
+ if (parsed.data.mailboxId && !(await assertRuleMailbox(loaded.db, loaded.user, parsed.data.mailboxId, loaded.rule.domainId))) {
+ return NextResponse.json({ error: "Mailbox access is required for the destination" }, { status: 403 });
}
await loaded.db.update(routingRules).set(toRuleColumns(parsed.data)).where(eq(routingRules.id, id));
diff --git a/src/app/api/routing-rules/domain/route.ts b/src/app/api/routing-rules/domain/route.ts
index 3bf2c7f..5d61bdd 100644
--- a/src/app/api/routing-rules/domain/route.ts
+++ b/src/app/api/routing-rules/domain/route.ts
@@ -2,15 +2,13 @@ import { NextResponse } from "next/server";
import { getDb } from "@/db";
import { routingRules } from "@/db/schema";
import { requireSessionUser } from "@/lib/api/auth";
-import { assertAdmin } from "@/lib/auth/admin";
import { getEnv } from "@/lib/cloudflare";
import { newId } from "@/lib/ids";
import { domainRoutingRuleSchema } from "@/lib/validators";
import {
assertRuleMailbox,
- getDomainOwnerId,
- getOwnedDomain,
- listDomainMailboxes,
+ getManagedDomainMailbox,
+ listManagedDomainMailboxes,
listDomainRules,
toRuleColumns,
} from "@/lib/domains/routing-rules";
@@ -20,26 +18,21 @@ export async function GET(request: Request) {
const auth = await requireSessionUser(env, request);
if (auth.error) return auth.error;
const user = auth.user;
- try {
- assertAdmin(user);
- } catch {
- return NextResponse.json({ error: "Forbidden" }, { status: 403 });
- }
-
- const domainId = new URL(request.url).searchParams.get("domainId");
- if (!domainId) {
- return NextResponse.json({ error: "domainId is required" }, { status: 400 });
+ const searchParams = new URL(request.url).searchParams;
+ const domainId = searchParams.get("domainId");
+ const mailboxId = searchParams.get("mailboxId");
+ if (!domainId || !mailboxId) {
+ return NextResponse.json({ error: "domainId and mailboxId are required" }, { status: 400 });
}
const db = getDb(env);
- const domain = await getOwnedDomain(db, getDomainOwnerId(user), domainId);
- if (!domain) {
- return NextResponse.json({ error: "Domain not found" }, { status: 404 });
+ if (!(await getManagedDomainMailbox(db, user, mailboxId, domainId))) {
+ return NextResponse.json({ error: "Mailbox access is required" }, { status: 403 });
}
return NextResponse.json({
rules: await listDomainRules(db, domainId),
- mailboxes: await listDomainMailboxes(db, domainId),
+ mailboxes: await listManagedDomainMailboxes(db, user, domainId),
});
}
@@ -48,32 +41,26 @@ export async function POST(request: Request) {
const auth = await requireSessionUser(env, request);
if (auth.error) return auth.error;
const user = auth.user;
- try {
- assertAdmin(user);
- } catch {
- return NextResponse.json({ error: "Forbidden" }, { 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 domain = await getOwnedDomain(db, getDomainOwnerId(user), parsed.data.domainId);
- if (!domain) {
- return NextResponse.json({ error: "Domain not found" }, { status: 404 });
+ const mailboxId = new URL(request.url).searchParams.get("mailboxId");
+ if (!mailboxId || !(await getManagedDomainMailbox(db, user, mailboxId, parsed.data.domainId))) {
+ return NextResponse.json({ error: "Mailbox access is required" }, { status: 403 });
}
- if (parsed.data.mailboxId && !(await assertRuleMailbox(db, parsed.data.mailboxId, domain.id))) {
- return NextResponse.json({ error: "Mailbox not found on this domain" }, { status: 404 });
+ if (parsed.data.mailboxId && !(await assertRuleMailbox(db, user, parsed.data.mailboxId, parsed.data.domainId))) {
+ return NextResponse.json({ error: "Mailbox access is required for the destination" }, { status: 403 });
}
const id = newId("rule");
await db.insert(routingRules).values({
id,
userId: user.id,
- domainId: domain.id,
+ domainId: parsed.data.domainId,
...toRuleColumns(parsed.data),
});
diff --git a/src/components/mailbox-provider-utils.ts b/src/components/mailbox-provider-utils.ts
index 3ccf231..e765023 100644
--- a/src/components/mailbox-provider-utils.ts
+++ b/src/components/mailbox-provider-utils.ts
@@ -35,6 +35,7 @@ export async function fetchMailboxOptions(force = false): Promise<MailboxOption[
.then((data) => {
const items = ((data as { mailboxes?: MailboxOption[] }).mailboxes ?? []).map((m) => ({
id: m.id,
+ domainId: m.domainId,
localPart: m.localPart,
hostname: m.hostname,
displayName: m.displayName,
diff --git a/src/components/mailbox-provider.tsx b/src/components/mailbox-provider.tsx
index 587eac4..56bdf66 100644
--- a/src/components/mailbox-provider.tsx
+++ b/src/components/mailbox-provider.tsx
@@ -19,6 +19,7 @@ import {
export type MailboxOption = {
id: string;
+ domainId: string;
localPart: string;
hostname: string;
displayName: string | null;
diff --git a/src/components/settings/domain-routing/domain-routing.tsx b/src/components/settings/domain-routing/domain-routing.tsx
index 1d953f9..ce32ba5 100644
--- a/src/components/settings/domain-routing/domain-routing.tsx
+++ b/src/components/settings/domain-routing/domain-routing.tsx
@@ -1,6 +1,6 @@
"use client";
-import { useMemo, useState } from "react";
+import { useState } from "react";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { Ban, Forward, Inbox, Pencil, Plus, Trash2 } from "lucide-react";
import { Badge } from "@/components/ui/badge";
@@ -18,6 +18,7 @@ import { Label } from "@/components/ui/label";
import { Select } from "@/components/ui/select";
import { Switch } from "@/components/ui/switch";
import { CardGridSkeleton } from "@/components/page-skeletons";
+import { useSelectedMailbox } from "@/components/mailbox-provider";
import type { DomainRule, DomainRuleInput } from "./types";
import {
ACTION_LABELS,
@@ -28,7 +29,6 @@ import {
describeRule,
emptyRuleInput,
fetchDomainRules,
- fetchRoutingDomains,
formatLastMatched,
ruleToInput,
updateDomainRule,
@@ -42,53 +42,50 @@ const ACTION_ICONS = {
export function DomainRouting() {
const qc = useQueryClient();
- const [selectedDomainId, setSelectedDomainId] = useState("");
+ const { selectedMailbox, isLoading: isMailboxLoading } = useSelectedMailbox();
const [dialogOpen, setDialogOpen] = useState(false);
const [editing, setEditing] = useState<DomainRule | null>(null);
const [form, setForm] = useState<DomainRuleInput>(emptyRuleInput(""));
const [error, setError] = useState<string | null>(null);
- const domains = useQuery({ queryKey: ["routing-domains"], queryFn: fetchRoutingDomains });
-
- // Derive the active domain rather than syncing it in an effect: until the operator picks one,
- // it is simply the first domain that loaded.
- const domainId = selectedDomainId || (domains.data?.[0]?.id ?? "");
+ const domainId = selectedMailbox?.domainId ?? "";
+ const mailboxId = selectedMailbox?.id ?? "";
+ const canManage = selectedMailbox?.permission === "full_access";
const rules = useQuery({
- queryKey: ["domain-rules", domainId],
- enabled: !!domainId,
- queryFn: () => fetchDomainRules(domainId),
+ queryKey: ["domain-rules", domainId, mailboxId],
+ enabled: !!domainId && !!mailboxId && canManage,
+ queryFn: () => fetchDomainRules(domainId, mailboxId),
});
- const hostname = useMemo(
- () => domains.data?.find((d) => d.id === domainId)?.hostname ?? "",
- [domains.data, domainId],
- );
+ const hostname = selectedMailbox?.hostname ?? "";
const mailboxes = rules.data?.mailboxes ?? [];
const save = useMutation({
mutationFn: () => {
const payload: DomainRuleInput = { ...form, domainId };
- return editing ? updateDomainRule(editing.id, payload) : createDomainRule(payload);
+ return editing
+ ? updateDomainRule(editing.id, payload, mailboxId)
+ : createDomainRule(payload, mailboxId);
},
onSuccess: () => {
setDialogOpen(false);
setEditing(null);
setError(null);
- qc.invalidateQueries({ queryKey: ["domain-rules", domainId] });
+ qc.invalidateQueries({ queryKey: ["domain-rules", domainId, mailboxId] });
},
onError: (e: Error) => setError(e.message),
});
const remove = useMutation({
- mutationFn: deleteDomainRule,
- onSuccess: () => qc.invalidateQueries({ queryKey: ["domain-rules", domainId] }),
+ mutationFn: (id: string) => deleteDomainRule(id, mailboxId),
+ onSuccess: () => qc.invalidateQueries({ queryKey: ["domain-rules", domainId, mailboxId] }),
});
const toggle = useMutation({
mutationFn: (rule: DomainRule) =>
- updateDomainRule(rule.id, { ...ruleToInput(rule), enabled: !rule.enabled }),
- onSuccess: () => qc.invalidateQueries({ queryKey: ["domain-rules", domainId] }),
+ updateDomainRule(rule.id, { ...ruleToInput(rule), enabled: !rule.enabled }, mailboxId),
+ onSuccess: () => qc.invalidateQueries({ queryKey: ["domain-rules", domainId, mailboxId] }),
});
function openCreate() {
@@ -118,22 +115,7 @@ export function DomainRouting() {
</p>
</div>
<div className="flex items-end gap-2">
- <div className="space-y-1">
- <Label htmlFor="routing-domain">Domain</Label>
- <Select
- id="routing-domain"
- value={domainId}
- onChange={(e) => setSelectedDomainId(e.target.value)}
- className="h-9"
- >
- {(domains.data ?? []).map((domain) => (
- <option key={domain.id} value={domain.id}>
- {domain.hostname}
- </option>
- ))}
- </Select>
- </div>
- <Button onClick={openCreate} disabled={!domainId}>
+ <Button onClick={openCreate} disabled={!mailboxId || !canManage}>
<Plus className="h-4 w-4" /> Add rule
</Button>
</div>
@@ -157,12 +139,18 @@ export function DomainRouting() {
</CardContent>
</Card>
- {domains.isLoading || rules.isLoading ? (
+ {isMailboxLoading || rules.isLoading ? (
<CardGridSkeleton />
- ) : !domains.data?.length ? (
+ ) : !mailboxId ? (
+ <Card>
+ <CardContent className="pt-6 text-sm text-neutral-500">
+ Select an inbox before creating routing rules.
+ </CardContent>
+ </Card>
+ ) : !canManage ? (
<Card>
<CardContent className="pt-6 text-sm text-neutral-500">
- Add a domain before creating routing rules.
+ Full access to the selected inbox is required to manage domain routing.
</CardContent>
</Card>
) : (
diff --git a/src/components/settings/domain-routing/types.d.ts b/src/components/settings/domain-routing/types.d.ts
index b5fca63..860a20f 100644
--- a/src/components/settings/domain-routing/types.d.ts
+++ b/src/components/settings/domain-routing/types.d.ts
@@ -41,9 +41,3 @@ export type DomainRuleInput = {
rejectReason?: string | null;
priority: number;
};
-
-export type RoutingDomain = {
- id: string;
- hostname: string;
- status: string;
-};
diff --git a/src/components/settings/domain-routing/utils.ts b/src/components/settings/domain-routing/utils.ts
index edbc20b..9a97f97 100644
--- a/src/components/settings/domain-routing/utils.ts
+++ b/src/components/settings/domain-routing/utils.ts
@@ -5,7 +5,6 @@ import type {
DomainRuleInput,
DomainRuleMailbox,
DomainRuleOperator,
- RoutingDomain,
} from "./types";
export const MATCH_FIELD_LABELS: Record<DomainRuleField, string> = {
@@ -37,23 +36,19 @@ async function readJson<T>(res: Response): Promise<T> {
return json;
}
-export async function fetchRoutingDomains(): Promise<RoutingDomain[]> {
- const res = await authFetch("/api/domains");
- const json = await readJson<{ domains: RoutingDomain[] }>(res);
- return json.domains ?? [];
-}
-
export async function fetchDomainRules(
domainId: string,
+ mailboxId: string,
): Promise<{ rules: DomainRule[]; mailboxes: DomainRuleMailbox[] }> {
- const res = await authFetch(`/api/routing-rules/domain?domainId=${encodeURIComponent(domainId)}`);
+ const params = new URLSearchParams({ domainId, mailboxId });
+ const res = await authFetch(`/api/routing-rules/domain?${params}`);
const json = await readJson<{ rules: DomainRule[]; mailboxes: DomainRuleMailbox[] }>(res);
return { rules: json.rules ?? [], mailboxes: json.mailboxes ?? [] };
}
-export async function createDomainRule(input: DomainRuleInput) {
+export async function createDomainRule(input: DomainRuleInput, mailboxId: string) {
return readJson(
- await authFetch("/api/routing-rules/domain", {
+ await authFetch(`/api/routing-rules/domain?${new URLSearchParams({ mailboxId })}`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(input),
@@ -61,9 +56,9 @@ export async function createDomainRule(input: DomainRuleInput) {
);
}
-export async function updateDomainRule(id: string, input: DomainRuleInput) {
+export async function updateDomainRule(id: string, input: DomainRuleInput, mailboxId: string) {
return readJson(
- await authFetch(`/api/routing-rules/domain/${id}`, {
+ await authFetch(`/api/routing-rules/domain/${id}?${new URLSearchParams({ mailboxId })}`, {
method: "PATCH",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(input),
@@ -71,8 +66,8 @@ export async function updateDomainRule(id: string, input: DomainRuleInput) {
);
}
-export async function deleteDomainRule(id: string) {
- return readJson(await authFetch(`/api/routing-rules/domain/${id}`, { method: "DELETE" }));
+export async function deleteDomainRule(id: string, mailboxId: string) {
+ return readJson(await authFetch(`/api/routing-rules/domain/${id}?${new URLSearchParams({ mailboxId })}`, { method: "DELETE" }));
}
export function describeRule(rule: DomainRule, mailboxes: DomainRuleMailbox[], hostname: string): string {
diff --git a/src/lib/domains/routing-rules.ts b/src/lib/domains/routing-rules.ts
index 49aa734..8f0bc43 100644
--- a/src/lib/domains/routing-rules.ts
+++ b/src/lib/domains/routing-rules.ts
@@ -1,7 +1,8 @@
import { and, asc, desc, eq } from "drizzle-orm";
import type { AppDatabase } from "@/db";
-import { domains, mailboxes, routingRules } from "@/db/schema";
+import { routingRules } from "@/db/schema";
import type { SessionUser } from "@/lib/auth/types";
+import { getMailboxAccessLevel, listAccessibleMailboxes } from "@/lib/mailboxes/access";
export type DomainRuleInput = {
domainId: string;
@@ -18,23 +19,6 @@ export type DomainRuleInput = {
priority: number;
};
-/**
- * Domains are owned by the admin who added them; team members with mailbox management
- * rights act on their creator's domains, mirroring the domains API.
- */
-export function getDomainOwnerId(user: Pick<SessionUser, "id" | "canManageMailboxes" | "createdByUserId">) {
- return user.canManageMailboxes && user.createdByUserId ? user.createdByUserId : user.id;
-}
-
-export async function getOwnedDomain(db: AppDatabase, ownerId: string, domainId: string) {
- const [domain] = await db
- .select()
- .from(domains)
- .where(and(eq(domains.id, domainId), eq(domains.userId, ownerId)))
- .limit(1);
- return domain ?? null;
-}
-
export async function listDomainRules(db: AppDatabase, domainId: string) {
return db
.select()
@@ -43,31 +27,37 @@ export async function listDomainRules(db: AppDatabase, domainId: string) {
.orderBy(desc(routingRules.priority), asc(routingRules.createdAt));
}
-export async function listDomainMailboxes(db: AppDatabase, domainId: string) {
- return db
- .select({
- id: mailboxes.id,
- localPart: mailboxes.localPart,
- displayName: mailboxes.displayName,
- disabled: mailboxes.disabled,
- })
- .from(mailboxes)
- .where(eq(mailboxes.domainId, domainId))
- .orderBy(asc(mailboxes.localPart));
+export async function getManagedDomainMailbox(
+ db: AppDatabase,
+ user: Pick<SessionUser, "id" | "email" | "role">,
+ mailboxId: string,
+ domainId: string,
+) {
+ const access = await getMailboxAccessLevel(db, user, mailboxId);
+ if (!access?.canManage || access.mailbox.domainId !== domainId) return null;
+ return access.mailbox;
+}
+
+export async function listManagedDomainMailboxes(
+ db: AppDatabase,
+ user: Pick<SessionUser, "id" | "email" | "role">,
+ domainId: string,
+) {
+ const accessible = await listAccessibleMailboxes(db, user);
+ return accessible
+ .filter((mailbox) => mailbox.domainId === domainId && mailbox.permission === "full_access")
+ .map(({ id, localPart, displayName, disabled }) => ({ id, localPart, displayName, disabled }))
+ .sort((a, b) => a.localPart.localeCompare(b.localPart));
}
-/** A destination mailbox must belong to the same domain as the rule. */
+/** A rule can deliver only to an inbox that the caller can fully manage. */
export async function assertRuleMailbox(
db: AppDatabase,
+ user: Pick<SessionUser, "id" | "email" | "role">,
mailboxId: string,
domainId: string,
): Promise<boolean> {
- const [mailbox] = await db
- .select({ id: mailboxes.id })
- .from(mailboxes)
- .where(and(eq(mailboxes.id, mailboxId), eq(mailboxes.domainId, domainId)))
- .limit(1);
- return !!mailbox;
+ return !!(await getManagedDomainMailbox(db, user, mailboxId, domainId));
}
export function toRuleColumns(input: DomainRuleInput) {