// VA-P23 · mailbox connect settings route (M09 Block B/D). Lists the current
// user's OWN mailboxes (read_all admins see every tenant mailbox) + the two
// provider connect actions + reconnect/disconnect. Connect redirects to the
// provider consent screen with a signed, provider-pinned state. Module off ->
// locked empty; missing email.read_own -> 404 (A.5.3).
import { type ActionFunctionArgs, type LoaderFunctionArgs, redirect, useLoaderData, useSearchParams, Form } from "react-router";
import { useTranslation } from "react-i18next";
import {
aggregateInitialSync,
buildEmailMailboxListVM,
emailMailboxProviderKey,
emailMailboxStatusKey,
type EmailMailboxListVM,
type EmailMailboxRow,
} from "@hivegrid/view-models";
import { getTranslations } from "~/locale/i18next.server";
import { validateCSRFToken } from "~/utils/session.server";
import { useRootData } from "~/utils/data/useRootData";
import {
EMAIL_PERMISSIONS,
canReadAllMailboxes,
canWriteEmail,
loadEmailInboxContext,
requireEmailRead,
requireMailboxVisibility,
} from "~/modules/emailInbox/routes/emailInboxAccess.server";
import { EMAIL_INBOX_MODULE_KEY, notFoundResponse } from "~/modules/emailInbox/routes/emailInboxRoutePaths";
import { getMailboxForTenant, listMailboxesForTenant, listMailboxesForUser, listSyncCursorsForMailboxes } from "~/modules/emailInbox/db/emailInbox.db.server";
import { MailboxConnectError, buildConnectUrl, configuredEmailProviders, disconnectMailbox } from "~/modules/emailInbox/services/MailboxConnectionService.server";
import type { EmailOAuthProvider } from "~/modules/emailInbox/services/oauthState.server";
import ServerError from "~/components/ui/errors/ServerError";
type LoaderData = { title: string; vm: EmailMailboxListVM };
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const ctx = await loadEmailInboxContext({ request, params });
const title = `${t("emailInbox.settings.title")} | ${process.env.APP_NAME}`;
if (!ctx.hasModule) {
return Response.json({
title,
vm: buildEmailMailboxListVM({ rows: [], canConnect: false, configuredProviders: { gmail: false, microsoft: false } }),
} satisfies LoaderData);
}
try {
requireEmailRead(ctx);
} catch {
throw notFoundResponse();
}
const mailboxes = canReadAllMailboxes(ctx) ? await listMailboxesForTenant(ctx.tenantId) : await listMailboxesForUser(ctx.tenantId, ctx.userId);
const cursors = await listSyncCursorsForMailboxes(
ctx.tenantId,
mailboxes.map((m) => m.id),
);
const rows: EmailMailboxRow[] = mailboxes.map((mailbox) => ({
id: mailbox.id,
provider: mailbox.provider,
providerKey: emailMailboxProviderKey(mailbox.provider),
emailAddress: mailbox.emailAddress,
displayName: mailbox.displayName,
isDefaultForUser: mailbox.isDefaultForUser,
isOwn: mailbox.ownerUserId === ctx.userId,
status: mailbox.status,
statusKey: emailMailboxStatusKey(mailbox.status),
lastSyncAt: mailbox.lastSyncAt ? mailbox.lastSyncAt.toISOString() : null,
lastErrorText: mailbox.lastErrorText,
initialSync: aggregateInitialSync(cursors.filter((c) => c.mailboxId === mailbox.id)),
}));
const vm = buildEmailMailboxListVM({
rows,
canConnect: canWriteEmail(ctx),
configuredProviders: configuredEmailProviders(),
});
return Response.json({ title, vm } satisfies LoaderData);
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
const ctx = await loadEmailInboxContext({ request, params, requireModule: true });
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
if (intent === "connect-gmail" || intent === "connect-microsoft") {
try {
requireEmailRead(ctx);
} catch {
throw notFoundResponse();
}
if (!canWriteEmail(ctx)) {
throw notFoundResponse();
}
const provider: EmailOAuthProvider = intent === "connect-gmail" ? "gmail" : "microsoft";
try {
const url = buildConnectUrl({ tenantId: ctx.tenantId, userId: ctx.userId, tenantSlug: params.tenant ?? "", provider });
return redirect(url);
} catch (error) {
if (error instanceof MailboxConnectError) {
return Response.json({ error: "emailInbox.settings.notConfigured" }, { status: 400 });
}
throw error;
}
}
if (intent === "disconnect") {
const mailboxId = String(form.get("mailboxId") ?? "");
const mailbox = mailboxId ? await getMailboxForTenant(ctx.tenantId, mailboxId) : null;
if (!mailbox) {
throw notFoundResponse();
}
// Owner may disconnect their own mailbox; read_all admins may force-disconnect.
requireMailboxVisibility(ctx, mailbox.ownerUserId);
if (mailbox.ownerUserId === ctx.userId && !canWriteEmail(ctx)) {
throw notFoundResponse();
}
await disconnectMailbox({ tenantId: ctx.tenantId, mailboxId });
return Response.json({ ok: true, disconnected: mailboxId });
}
throw notFoundResponse();
};
function MailboxRowItem({ row, csrf }: { row: EmailMailboxRow; csrf?: string }) {
const { t } = useTranslation();
return (
{row.emailAddress}
{t(row.providerKey)}
{row.lastSyncAt && (
{t("emailInbox.settings.lastSync")}: {new Date(row.lastSyncAt).toLocaleString()}
)}
{t(row.statusKey)}
{row.isOwn && (
)}
{row.initialSync.status !== "completed" && (
{t(row.initialSync.statusKey)}
{row.initialSync.progressPercent !== null && ` — ${row.initialSync.progressPercent}%`}
{row.initialSync.fetchedCount !== null && ` (${t("emailInbox.settings.initialSync.fetched", { count: row.initialSync.fetchedCount })})`}
)}
{row.lastErrorText && (
{row.lastErrorText.startsWith("emailInbox.") ? t(row.lastErrorText) : row.lastErrorText}
)}
);
}
export default function EmailSettingsRoute() {
const { t } = useTranslation();
const rootData = useRootData();
const { vm } = useLoaderData();
const [searchParams] = useSearchParams();
const flash = searchParams.get("email");
if (vm.status !== "ready" || !vm.data) {
return ;
}
const { rows, canConnect, configuredProviders, emptyHeadlineKey, emptyBodyKey, notConfiguredKey } = vm.data;
const anyConfigured = configuredProviders.gmail || configuredProviders.microsoft;
return (
{t("emailInbox.settings.title")}
{t("emailInbox.settings.subtitle")}
{flash === "connected" && (
{t("emailInbox.settings.flash.connected")}
)}
{flash === "error" && (
{t("emailInbox.settings.flash.error")}
)}
{!anyConfigured && (
{t(notConfiguredKey)}
)}
{canConnect && anyConfigured && (
{configuredProviders.gmail && (
)}
{configuredProviders.microsoft && (
)}
)}
{rows.length === 0 ? (
{t(emptyHeadlineKey)}
{t(emptyBodyKey)}
) : (
)}
);
}
export function ErrorBoundary() {
return ;
}
export const handle = { moduleKey: EMAIL_INBOX_MODULE_KEY };