Skip to content

Email for professionals and teams

3.7 KB
Raw Blame
import { NextResponse } from "next/server";
import { and, eq, or } from "drizzle-orm";
import { getEnv } from "@/lib/cloudflare";
import { getDb } from "@/db";
import { domains, mailboxAliases, mailboxes, users } from "@/db/schema";
import { authenticateAdminApiKey, canShareAdminMailboxes } from "@/lib/api/admin-auth";
import { newId } from "@/lib/ids";
import { mailboxSchema } from "@/lib/validators";
import { ensureMailboxDomainRouting } from "@/lib/mailboxes/domain-addresses";

export async function GET(request: Request) {
	const env = getEnv();
	const auth = await authenticateAdminApiKey(env, request, "mailboxes");
	if (!auth) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
	const rows = await getDb(env).select({
		id: mailboxes.id, userId: mailboxes.userId, domainId: mailboxes.domainId,
		localPart: mailboxes.localPart, hostname: domains.hostname,
		displayName: mailboxes.displayName, type: mailboxes.type,
		disabled: mailboxes.disabled, createdAt: mailboxes.createdAt,
	}).from(mailboxes).innerJoin(users, eq(mailboxes.userId, users.id)).innerJoin(domains, eq(mailboxes.domainId, domains.id))
		.where(or(eq(users.id, auth.userId), eq(users.createdByUserId, auth.userId)));
	return NextResponse.json({ mailboxes: rows });
}

export async function POST(request: Request) {
	const env = getEnv();
	const auth = await authenticateAdminApiKey(env, request, "mailboxes");
	if (!auth) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
	const parsed = mailboxSchema.safeParse(await request.json().catch(() => null));
	if (!parsed.success) return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
	const db = getDb(env);
	const mailboxType = parsed.data.type ?? "personal";
	if (mailboxType === "shared" && !(await canShareAdminMailboxes(env))) return NextResponse.json({ error: "A Team license is required to create shared inboxes" }, { status: 403 });
	const ownerUserId = mailboxType === "shared" ? auth.userId : parsed.data.ownerUserId ?? auth.userId;
	if (ownerUserId !== auth.userId) {
		const [owner] = await db.select({ id: users.id }).from(users).where(and(eq(users.id, ownerUserId), eq(users.createdByUserId, auth.userId))).limit(1);
		if (!owner) return NextResponse.json({ error: "Account not found" }, { status: 404 });
	}
	const [domain] = await db.select().from(domains).where(and(eq(domains.id, parsed.data.domainId), eq(domains.userId, auth.userId))).limit(1);
	if (!domain) return NextResponse.json({ error: "Domain not found" }, { status: 404 });
	const localPart = parsed.data.localPart.toLowerCase();
	const [existing] = await db.select({ id: mailboxes.id }).from(mailboxes).where(and(eq(mailboxes.domainId, domain.id), eq(mailboxes.localPart, localPart))).limit(1);
	if (existing) return NextResponse.json({ error: "Mailbox already exists" }, { status: 409 });
	const [alias] = await db.select({ id: mailboxAliases.id }).from(mailboxAliases).where(and(eq(mailboxAliases.domainId, domain.id), eq(mailboxAliases.localPart, localPart))).limit(1);
	if (alias) return NextResponse.json({ error: "An alias already uses this address" }, { status: 409 });
	const id = newId("mbx");
	await db.insert(mailboxes).values({ id, userId: ownerUserId, domainId: domain.id, localPart, displayName: parsed.data.displayName, type: mailboxType });
	try {
		await ensureMailboxDomainRouting(env, db, { id, domainId: domain.id, localPart, useAllDomains: true });
	} catch (error) {
		await db.delete(mailboxes).where(eq(mailboxes.id, id));
		return NextResponse.json({ error: error instanceof Error ? error.message : "Failed to create Cloudflare routing rule" }, { status: 502 });
	}
	return NextResponse.json({ id, address: `${localPart}@${domain.hostname}`, type: mailboxType }, { status: 201 });
}