The Open Source DocuSign Alternative.
TypeScript digital-signaturedocument-signingdocusign-alternativee-signatureesignesignaturenext-authnextjsopen-sourcepades-standardpdfpdf-signpdf-signaturepostgresqlprismaself-hostedsigningtypescript
feat: add admin email domain management and sync job (#2538)
Lucas Smithc112392da9e2
diff --git a/.agents/plans/warm-purple-flower-custom-email-domain-sync-and-recovery.md b/.agents/plans/warm-purple-flower-custom-email-domain-sync-and-recovery.mdnew file mode 100644index 000000000..c0a566169--- /dev/null+++ b/.agents/plans/warm-purple-flower-custom-email-domain-sync-and-recovery.md@@ -0,0 +1,263 @@+---+date: 2026-02-24+title: Custom Email Domain Sync And Recovery+---++## Problem Statement++Custom email domains configured via AWS SES can get stuck in a `PENDING` state or fail validation silently. Currently, there is **no automated verification** -- users must manually click "Sync" in the UI to check domain status. If a domain fails to validate, the only option is to delete it and recreate it, which generates new DKIM keys and requires the user to update their DNS records.++### Current Pain Points++1. **No background sync** -- Domain verification status is never checked automatically; users must manually click "Sync"+2. **Stuck domains** -- Domains can remain in `PENDING` state indefinitely with no alerting or auto-recovery+3. **Failed recovery requires DNS changes** -- Deleting and recreating a domain generates new keys, forcing the user to update DNS records+4. **No visibility into failure duration** -- There's no tracking of how long a domain has been pending++## Proposed Solution++### 1. Hourly Background Sync Job++Create a new cron job (`internal.sync-email-domains`) that runs every hour to automatically verify all `PENDING` email domains.++**Job Definition:** `packages/lib/jobs/definitions/internal/sync-email-domains.ts`+**Job Handler:** `packages/lib/jobs/definitions/internal/sync-email-domains.handler.ts`++**Pattern:** Follow the existing `cleanup-rate-limits` cron job pattern:++- `cron: '0 * * * *'` (every hour, on the hour)+- Empty `z.object({})` schema (no payload needed)+- Register in `packages/lib/jobs/client.ts`++**Handler Logic:**++1. Query all `EmailDomain` records with `status: 'PENDING'`+2. For each domain, call `verifyEmailDomain(emailDomainId)` which:+ - Calls AWS SES `GetEmailIdentityCommand` to check current verification status+ - Updates DB status to `ACTIVE` if verified, keeps `PENDING` otherwise+3. Log results via `io.logger` (how many checked, how many transitioned to ACTIVE)+4. Process domains in batches to avoid overwhelming SES API rate limits+5. Add error handling per-domain so one failure doesn't stop the entire sweep++### 2. Schema Changes -- Track Pending Duration++Add a `lastVerifiedAt` column to the `EmailDomain` model to track when verification was last attempted, enabling "stale domain" detection.++**File:** `packages/prisma/schema.prisma`++```prisma+model EmailDomain {+ // ... existing fields ...+ lastVerifiedAt DateTime? // Last time verification was checked against SES+}+```++**Migration:** Create a new Prisma migration for this column addition.++**Updates needed:**++- `verify-email-domain.ts` -- Update `lastVerifiedAt` when verification is checked+- The sync job handler -- Use `lastVerifiedAt` to avoid re-checking domains that were just verified++### 3. Domain Re-registration (Recovery) -- Delete & Recreate in SES Without Changing Keys++Add a new "Re-register" action that deletes the SES identity and recreates it using the **same** DKIM key pair stored in the database, so the user's DNS records remain valid.++#### 3a. New Service Function++**File:** `packages/ee/server-only/lib/reregister-email-domain.ts`++```typescript+export const reregisterEmailDomain = async (options: { emailDomainId: string }) => {+ // 1. Fetch the EmailDomain record (including encrypted privateKey)+ // 2. Decrypt the private key using DOCUMENSO_ENCRYPTION_KEY+ // 3. Call DeleteEmailIdentityCommand on SES (ignore NotFoundException)+ // 4. Call CreateEmailIdentityCommand with BYODKIM using the SAME selector + private key+ // 5. Update EmailDomain status back to PENDING, update lastVerifiedAt+ // 6. Return the updated domain+};+```++Key points:++- Uses the existing encrypted `privateKey` from the DB -- no new key generation+- Uses the existing `selector` -- DNS records stay the same+- Deletes first, then recreates -- handles cases where SES state is corrupted+- Resets status to `PENDING` since verification will need to re-occur+- Uses `verifyDomainWithDKIM()` from `create-email-domain.ts` (may need to extract/export this helper)++#### 3b. Admin TRPC Routes (Find, Get, Re-register)++All email domain admin routes use `adminProcedure` -- requires system-level `Role.ADMIN`.++**Find (list) route:**+**File:** `packages/trpc/server/admin-router/find-email-domains.ts`+**Types:** `packages/trpc/server/admin-router/find-email-domains.types.ts`++- Query route: `admin.emailDomain.find`+- Input: `{ query?: string, page?: number, perPage?: number, status?: EmailDomainStatus }`+- Extends `ZFindSearchParamsSchema` with optional `status` filter+- Returns standard `ZFindResultResponse` with email domain data including: id, domain, status, selector, createdAt, lastVerifiedAt, organisation name, email count+- Prisma query filters by domain name (LIKE search on `query`), optional status, joins organisation for name, counts emails++**Get (detail) route:**+**File:** `packages/trpc/server/admin-router/get-email-domain.ts`+**Types:** `packages/trpc/server/admin-router/get-email-domain.types.ts`++- Query route: `admin.emailDomain.get`+- Input: `{ emailDomainId: string }`+- Returns full email domain detail: all fields (except privateKey), organisation info, list of associated emails, DNS records (generated from publicKey + selector)+- Omits `privateKey` from response++**Re-register (mutation) route:**+**File:** `packages/trpc/server/admin-router/reregister-email-domain.ts`+**Types:** `packages/trpc/server/admin-router/reregister-email-domain.types.ts`++- Mutation route: `admin.emailDomain.reregister`+- Input: `{ emailDomainId: string }`+- Calls `reregisterEmailDomain()`+- Rationale: Re-registration is a recovery/operational action that deletes and recreates an SES identity. This is a privileged operation that should only be performed by platform operators, not self-service by org admins.++#### 3c. Register in Admin Router++**File:** `packages/trpc/server/admin-router/router.ts`++Add a new `emailDomain` namespace to the admin router:++```typescript+emailDomain: {+ find: findEmailDomainsRoute,+ get: getEmailDomainRoute,+ reregister: reregisterEmailDomainRoute,+},+```++#### 3d. Admin Panel UI -- Email Domains Section++**List page:** `apps/remix/app/routes/_authenticated+/admin+/email-domains._index.tsx`++- New admin panel page at `/admin/email-domains`+- Follow the existing admin documents list pattern (client-side TRPC data fetching)+- Search input (debounced) filtering by domain name+- Status filter dropdown (All / Pending / Active)+- DataTable with columns: Domain, Organisation, Status (badge), Email Count, Created, Last Verified, Actions+- Actions dropdown per row: View details, Re-register+- Pagination via `DataTablePagination`++**Detail page:** `apps/remix/app/routes/_authenticated+/admin+/email-domains.$id.tsx`++- Shows full domain details: domain, selector, status, organisation, created date, last verified date+- Shows DNS records (DKIM + SPF) with copy buttons (reuse `organisation-email-domain-records-dialog` pattern)+- Table of associated organisation emails+- "Re-register" button with confirmation dialog explaining the action (SES identity will be deleted and recreated with the same keys)+- "Verify Now" button to manually trigger a verification check+- Shows how long the domain has been pending (using `lastVerifiedAt` or `createdAt`)++**Navigation:** Add menu item to admin sidebar in `_layout.tsx`:++```tsx+<Button+ variant="ghost"+ className={cn(+ 'justify-start md:w-full',+ pathname?.startsWith('/admin/email-domains') && 'bg-secondary',+ )}+ asChild+>+ <Link to="/admin/email-domains">+ <MailIcon className="mr-2 h-5 w-5" />+ <Trans>Email Domains</Trans>+ </Link>+</Button>+```++**Table component:** `apps/remix/app/components/tables/admin-email-domains-table.tsx` (optional -- can be inline in the route file like the documents page)++#### 3e. Automatic Re-registration in Sync Job (Optional Enhancement)++In the hourly sync job, after checking verification status, if a domain has been `PENDING` for more than 48 hours:++- Automatically call `reregisterEmailDomain()` to attempt recovery+- Log the auto-recovery attempt+- This provides a self-healing mechanism without user intervention++## Implementation Plan++### Phase 1: Background Sync Job (Core)++1. Create `sync-email-domains.ts` job definition with hourly cron+2. Create `sync-email-domains.handler.ts` with batch verification logic+3. Register job in `packages/lib/jobs/client.ts`+4. Add error handling and logging++### Phase 2: Schema Enhancement++5. Add `lastVerifiedAt` column to `EmailDomain` model+6. Create Prisma migration+7. Update `verifyEmailDomain()` to set `lastVerifiedAt` on each check+8. Update sync job to use `lastVerifiedAt` for intelligent scheduling++### Phase 3: Admin Email Domains Panel++9. Create `find-email-domains` admin TRPC route + types (list/search with pagination and status filter)+10. Create `get-email-domain` admin TRPC route + types (detail view with org info, emails, DNS records)+11. Register find + get routes in admin router under `emailDomain` namespace+12. Create admin list page (`admin+/email-domains._index.tsx`) with search, status filter, DataTable+13. Create admin detail page (`admin+/email-domains.$id.tsx`) with domain info, emails table, DNS records+14. Add "Email Domains" menu item to admin sidebar (`_layout.tsx`)++### Phase 4: Re-registration Feature++15. Extract `verifyDomainWithDKIM()` as a shared helper (if not already exported)+16. Create `reregisterEmailDomain()` service function+17. Create `reregister-email-domain` admin TRPC mutation route + types+18. Register reregister route in admin router under `emailDomain.reregister`+19. Add "Re-register" button + confirmation dialog on admin detail page++### Phase 5: Auto-Recovery (Optional)++20. Add 48-hour stale detection logic to sync job+21. Auto-trigger re-registration for stale domains+22. Add logging/notifications for auto-recovery events++## Files to Create/Modify++### New Files++- `packages/lib/jobs/definitions/internal/sync-email-domains.ts`+- `packages/lib/jobs/definitions/internal/sync-email-domains.handler.ts`+- `packages/ee/server-only/lib/reregister-email-domain.ts`+- `packages/trpc/server/admin-router/find-email-domains.ts`+- `packages/trpc/server/admin-router/find-email-domains.types.ts`+- `packages/trpc/server/admin-router/get-email-domain.ts`+- `packages/trpc/server/admin-router/get-email-domain.types.ts`+- `packages/trpc/server/admin-router/reregister-email-domain.ts`+- `packages/trpc/server/admin-router/reregister-email-domain.types.ts`+- `apps/remix/app/routes/_authenticated+/admin+/email-domains._index.tsx`+- `apps/remix/app/routes/_authenticated+/admin+/email-domains.$id.tsx`++### Modified Files++- `packages/prisma/schema.prisma` -- Add `lastVerifiedAt` field+- `packages/lib/jobs/client.ts` -- Register new sync job+- `packages/ee/server-only/lib/verify-email-domain.ts` -- Update `lastVerifiedAt`+- `packages/ee/server-only/lib/create-email-domain.ts` -- Export `verifyDomainWithDKIM` helper+- `packages/trpc/server/admin-router/router.ts` -- Add `emailDomain.{find, get, reregister}` routes+- `apps/remix/app/routes/_authenticated+/admin+/_layout.tsx` -- Add "Email Domains" nav item to sidebar+- New Prisma migration file++## Technical Considerations++1. **SES API Rate Limits** -- AWS SES has rate limits on `GetEmailIdentityCommand`. The sync job should process domains in batches with small delays between calls (e.g., 5-10 per batch with 1s delay).++2. **Concurrency** -- The local job provider has deterministic deduplication via SHA-256 IDs, so multiple app instances won't run the same cron tick twice.++3. **Error Isolation** -- Each domain verification in the sync job should be wrapped in try/catch so one failing domain doesn't prevent others from being checked.++4. **Re-registration Safety** -- The re-register function should be idempotent. Deleting a non-existent SES identity should be handled gracefully (already done in `deleteEmailDomain`).++5. **Private Key Security** -- The private key is encrypted at rest and should only be decrypted transiently during re-registration. It should never be logged or exposed in API responses.++6. **Feature Gating** -- The sync job should only process domains belonging to organisations with active `emailDomains` claim flags. This prevents processing domains for orgs that have downgraded.++7. **Observability** -- Add structured logging to the sync job so operations teams can monitor domain verification health across all tenants.diff --git a/apps/remix/app/routes/_authenticated+/admin+/_layout.tsx b/apps/remix/app/routes/_authenticated+/admin+/_layout.tsxindex 8757372b1..43fe8feda 100644--- a/apps/remix/app/routes/_authenticated+/admin+/_layout.tsx+++ b/apps/remix/app/routes/_authenticated+/admin+/_layout.tsx@@ -3,6 +3,7 @@ import {BarChart3,Building2Icon,FileStack,+ MailIcon,Settings,Trophy,Users,@@ -122,6 +123,20 @@ export default function AdminLayout({ loaderData }: Route.ComponentProps) {</Link></Button>+ <Button+ variant="ghost"+ className={cn(+ 'justify-start md:w-full',+ pathname?.startsWith('/admin/email-domains') && 'bg-secondary',+ )}+ asChild+ >+ <Link to="/admin/email-domains">+ <MailIcon className="mr-2 h-5 w-5" />+ <Trans>Email Domains</Trans>+ </Link>+ </Button>+<Buttonvariant="ghost"className={cn(diff --git a/apps/remix/app/routes/_authenticated+/admin+/email-domains.$id.tsx b/apps/remix/app/routes/_authenticated+/admin+/email-domains.$id.tsxnew file mode 100644index 000000000..442a809b6--- /dev/null+++ b/apps/remix/app/routes/_authenticated+/admin+/email-domains.$id.tsx@@ -0,0 +1,295 @@+import { useMemo } from 'react';++import { msg } from '@lingui/core/macro';+import { useLingui } from '@lingui/react';+import { Trans } from '@lingui/react/macro';+import { EmailDomainStatus } from '@prisma/client';+import { CheckCircle2Icon, ClockIcon, CopyIcon, RotateCcwIcon } from 'lucide-react';+import { DateTime } from 'luxon';+import { Link, redirect } from 'react-router';+import { match } from 'ts-pattern';++import { generateEmailDomainRecords } from '@documenso/lib/utils/email-domains';+import { trpc } from '@documenso/trpc/react';+import {+ AlertDialog,+ AlertDialogAction,+ AlertDialogCancel,+ AlertDialogContent,+ AlertDialogDescription,+ AlertDialogFooter,+ AlertDialogHeader,+ AlertDialogTitle,+ AlertDialogTrigger,+} from '@documenso/ui/primitives/alert-dialog';+import { Badge } from '@documenso/ui/primitives/badge';+import { Button } from '@documenso/ui/primitives/button';+import type { DataTableColumnDef } from '@documenso/ui/primitives/data-table';+import { DataTable } from '@documenso/ui/primitives/data-table';+import { useToast } from '@documenso/ui/primitives/use-toast';++import type { Route } from './+types/email-domains.$id';++export function loader({ params }: Route.LoaderArgs) {+ const id = params.id;++ if (!id) {+ throw redirect('/admin/email-domains');+ }++ return { emailDomainId: id };+}++export default function AdminEmailDomainDetailPage({ loaderData }: Route.ComponentProps) {+ const { emailDomainId } = loaderData;++ const { _, i18n } = useLingui();+ const { toast } = useToast();++ const {+ data: emailDomain,+ isPending: isLoading,+ refetch,+ } = trpc.admin.emailDomain.get.useQuery({ emailDomainId });++ const { mutate: reregisterDomain, isPending: isReregistering } =+ trpc.admin.emailDomain.reregister.useMutation({+ onSuccess: () => {+ toast({+ title: _(msg`Domain re-registered`),+ description: _(+ msg`The SES identity has been deleted and recreated with the same keys. DNS records remain unchanged.`,+ ),+ });++ void refetch();+ },+ onError: () => {+ toast({+ title: _(msg`Error`),+ description: _(msg`Failed to re-register email domain`),+ variant: 'destructive',+ });+ },+ });++ const dnsRecords = useMemo(() => {+ if (!emailDomain) {+ return [];+ }++ return generateEmailDomainRecords(emailDomain.selector, emailDomain.publicKey);+ }, [emailDomain]);++ const emailColumns = useMemo(() => {+ return [+ {+ header: _(msg`Email`),+ accessorKey: 'email',+ },+ {+ header: _(msg`Display Name`),+ accessorKey: 'emailName',+ },+ {+ header: _(msg`Created`),+ accessorKey: 'createdAt',+ cell: ({ row }) => i18n.date(row.original.createdAt),+ },+ ] satisfies DataTableColumnDef<NonNullable<typeof emailDomain>['emails'][number]>[];+ }, []);++ const onCopyToClipboard = async (text: string) => {+ await navigator.clipboard.writeText(text);++ toast({+ title: _(msg`Copied to clipboard`),+ });+ };++ if (isLoading || !emailDomain) {+ return (+ <div>+ <h2 className="text-4xl font-semibold">+ <Trans>Email Domain</Trans>+ </h2>+ <p className="mt-4 text-muted-foreground">+ <Trans>Loading...</Trans>+ </p>+ </div>+ );+ }++ const pendingDuration =+ emailDomain.status === EmailDomainStatus.PENDING+ ? DateTime.fromJSDate(new Date(emailDomain.createdAt)).toRelative()+ : null;++ return (+ <div>+ <div className="flex items-start justify-between">+ <div className="flex items-center gap-x-4">+ <h2 className="text-2xl font-semibold">{emailDomain.domain}</h2>++ {match(emailDomain.status)+ .with(EmailDomainStatus.ACTIVE, () => (+ <Badge>+ <CheckCircle2Icon className="mr-2 h-4 w-4 text-green-500 dark:text-green-300" />+ <Trans>Active</Trans>+ </Badge>+ ))+ .with(EmailDomainStatus.PENDING, () => (+ <Badge variant="warning">+ <ClockIcon className="mr-2 h-4 w-4 text-yellow-500 dark:text-yellow-200" />+ <Trans>Pending</Trans>+ </Badge>+ ))+ .exhaustive()}+ </div>+ </div>++ <div className="mt-4 text-sm text-muted-foreground">+ <div>+ <Trans>ID</Trans>: {emailDomain.id}+ </div>+ <div>+ <Trans>Organisation</Trans>:{' '}+ <Link+ to={`/admin/organisations/${emailDomain.organisation.id}`}+ className="hover:underline"+ >+ {emailDomain.organisation.name}+ </Link>+ </div>+ <div>+ <Trans>Selector</Trans>: {emailDomain.selector}+ </div>+ <div>+ <Trans>Created</Trans>: {i18n.date(emailDomain.createdAt, DateTime.DATETIME_MED)}+ </div>+ <div>+ <Trans>Last Verified</Trans>:{' '}+ {emailDomain.lastVerifiedAt+ ? i18n.date(emailDomain.lastVerifiedAt, DateTime.DATETIME_MED)+ : '-'}+ </div>+ {pendingDuration && (+ <div className="mt-1 text-yellow-600 dark:text-yellow-400">+ <Trans>Pending since</Trans>: {pendingDuration}+ </div>+ )}+ </div>++ <hr className="my-4" />++ <h3 className="text-lg font-semibold">+ <Trans>Admin Actions</Trans>+ </h3>++ <div className="mt-2 flex gap-x-4">+ <AlertDialog>+ <AlertDialogTrigger asChild>+ <Button variant="outline" loading={isReregistering}>+ <RotateCcwIcon className="mr-2 h-4 w-4" />+ <Trans>Re-register</Trans>+ </Button>+ </AlertDialogTrigger>++ <AlertDialogContent>+ <AlertDialogHeader>+ <AlertDialogTitle>+ <Trans>Re-register Email Domain</Trans>+ </AlertDialogTitle>++ <AlertDialogDescription>+ <Trans>+ This will delete the existing SES identity for{' '}+ <strong>{emailDomain.domain}</strong> and recreate it using the same DKIM keys.+ The user will not need to update their DNS records. The domain status will be+ reset to Pending.+ </Trans>+ </AlertDialogDescription>+ </AlertDialogHeader>++ <AlertDialogFooter>+ <AlertDialogCancel>+ <Trans>Cancel</Trans>+ </AlertDialogCancel>++ <AlertDialogAction+ onClick={() => reregisterDomain({ emailDomainId: emailDomain.id })}+ >+ <Trans>Re-register</Trans>+ </AlertDialogAction>+ </AlertDialogFooter>+ </AlertDialogContent>+ </AlertDialog>+ </div>++ <hr className="my-4" />++ <h3 className="text-lg font-semibold">+ <Trans>DNS Records</Trans>+ </h3>++ <div className="mt-4 space-y-4">+ {dnsRecords.map((record, index) => (+ <div key={index} className="rounded-lg border p-4">+ <div className="flex items-center justify-between">+ <div className="text-sm font-medium">+ {record.type} <Trans>Record</Trans>+ </div>++ <Button+ variant="ghost"+ size="sm"+ onClick={() => void onCopyToClipboard(record.value)}+ >+ <CopyIcon className="mr-2 h-4 w-4" />+ <Trans>Copy Value</Trans>+ </Button>+ </div>++ <div className="mt-2 space-y-1 text-sm">+ <div>+ <span className="text-muted-foreground">+ <Trans>Name</Trans>:{' '}+ </span>+ <code className="rounded bg-muted px-1 py-0.5">{record.name}</code>+ </div>+ <div>+ <span className="text-muted-foreground">+ <Trans>Value</Trans>:{' '}+ </span>+ <code className="block break-all rounded bg-muted px-1 py-0.5">{record.value}</code>+ </div>+ </div>+ </div>+ ))}+ </div>++ <hr className="my-4" />++ <h3 className="text-lg font-semibold">+ <Trans>Emails</Trans> ({emailDomain.emails.length})+ </h3>++ <div className="mt-4">+ {emailDomain.emails.length > 0 ? (+ <DataTable+ columns={emailColumns}+ data={emailDomain.emails}+ perPage={emailDomain.emails.length}+ currentPage={1}+ totalPages={1}+ onPaginationChange={() => {}}+ />+ ) : (+ <p className="text-sm text-muted-foreground">+ <Trans>No emails configured for this domain.</Trans>+ </p>+ )}+ </div>+ </div>+ );+}diff --git a/apps/remix/app/routes/_authenticated+/admin+/email-domains._index.tsx b/apps/remix/app/routes/_authenticated+/admin+/email-domains._index.tsxnew file mode 100644index 000000000..669747e6d--- /dev/null+++ b/apps/remix/app/routes/_authenticated+/admin+/email-domains._index.tsx@@ -0,0 +1,207 @@+import { useMemo, useState } from 'react';++import { msg } from '@lingui/core/macro';+import { useLingui } from '@lingui/react';+import { Trans } from '@lingui/react/macro';+import { EmailDomainStatus } from '@prisma/client';+import { CheckCircle2Icon, ClockIcon, Loader } from 'lucide-react';+import { Link, useSearchParams } from 'react-router';+import { match } from 'ts-pattern';++import { useDebouncedValue } from '@documenso/lib/client-only/hooks/use-debounced-value';+import { useUpdateSearchParams } from '@documenso/lib/client-only/hooks/use-update-search-params';+import { trpc } from '@documenso/trpc/react';+import { Badge } from '@documenso/ui/primitives/badge';+import { Button } from '@documenso/ui/primitives/button';+import type { DataTableColumnDef } from '@documenso/ui/primitives/data-table';+import { DataTable } from '@documenso/ui/primitives/data-table';+import { DataTablePagination } from '@documenso/ui/primitives/data-table-pagination';+import { Input } from '@documenso/ui/primitives/input';+import {+ Select,+ SelectContent,+ SelectItem,+ SelectTrigger,+ SelectValue,+} from '@documenso/ui/primitives/select';++export default function AdminEmailDomainsPage() {+ const { _, i18n } = useLingui();++ const [searchParams] = useSearchParams();+ const updateSearchParams = useUpdateSearchParams();++ const [term, setTerm] = useState(() => searchParams?.get?.('term') ?? '');+ const debouncedTerm = useDebouncedValue(term, 500);++ const page = searchParams?.get?.('page') ? Number(searchParams.get('page')) : undefined;+ const perPage = searchParams?.get?.('perPage') ? Number(searchParams.get('perPage')) : undefined;+ const statusParam = searchParams?.get?.('status') ?? 'ALL';++ const statusFilter =+ statusParam === 'PENDING' || statusParam === 'ACTIVE' ? statusParam : undefined;++ const { data: findEmailDomainsData, isPending: isFindEmailDomainsLoading } =+ trpc.admin.emailDomain.find.useQuery(+ {+ query: debouncedTerm,+ page: page || 1,+ perPage: perPage || 20,+ status: statusFilter,+ },+ {+ placeholderData: (previousData) => previousData,+ },+ );++ const results = findEmailDomainsData ?? {+ data: [],+ perPage: 20,+ currentPage: 1,+ totalPages: 1,+ };++ const columns = useMemo(() => {+ return [+ {+ header: _(msg`Domain`),+ accessorKey: 'domain',+ cell: ({ row }) => (+ <Link+ to={`/admin/email-domains/${row.original.id}`}+ className="block max-w-[10rem] truncate font-medium hover:underline md:max-w-[15rem]"+ >+ {row.original.domain}+ </Link>+ ),+ },+ {+ header: _(msg`Organisation`),+ accessorKey: 'organisation',+ cell: ({ row }) => (+ <Link+ to={`/admin/organisations/${row.original.organisation.id}`}+ className="hover:underline"+ >+ {row.original.organisation.name}+ </Link>+ ),+ },+ {+ header: _(msg`Status`),+ accessorKey: 'status',+ cell: ({ row }) =>+ match(row.original.status)+ .with(EmailDomainStatus.ACTIVE, () => (+ <Badge>+ <CheckCircle2Icon className="mr-2 h-4 w-4 text-green-500 dark:text-green-300" />+ <Trans>Active</Trans>+ </Badge>+ ))+ .with(EmailDomainStatus.PENDING, () => (+ <Badge variant="warning">+ <ClockIcon className="mr-2 h-4 w-4 text-yellow-500 dark:text-yellow-200" />+ <Trans>Pending</Trans>+ </Badge>+ ))+ .exhaustive(),+ },+ {+ header: _(msg`Emails`),+ accessorKey: '_count',+ cell: ({ row }) => row.original._count.emails,+ },+ {+ header: _(msg`Created`),+ accessorKey: 'createdAt',+ cell: ({ row }) => i18n.date(row.original.createdAt),+ },+ {+ header: _(msg`Last Verified`),+ accessorKey: 'lastVerifiedAt',+ cell: ({ row }) =>+ row.original.lastVerifiedAt ? i18n.date(row.original.lastVerifiedAt) : '-',+ },+ {+ header: _(msg`Actions`),+ cell: ({ row }) => (+ <Button asChild variant="outline" size="sm">+ <Link to={`/admin/email-domains/${row.original.id}`}>+ <Trans>View</Trans>+ </Link>+ </Button>+ ),+ },+ ] satisfies DataTableColumnDef<(typeof results)['data'][number]>[];+ }, []);++ const onPaginationChange = (newPage: number, newPerPage: number) => {+ updateSearchParams({+ page: newPage,+ perPage: newPerPage,+ });+ };++ const onStatusChange = (value: string) => {+ updateSearchParams({+ status: value === 'ALL' ? undefined : value,+ page: 1,+ });+ };++ return (+ <div>+ <h2 className="text-4xl font-semibold">+ <Trans>Email Domains</Trans>+ </h2>++ <div className="mt-8">+ <div className="flex flex-col gap-4 sm:flex-row">+ <Input+ className="flex-1"+ type="search"+ placeholder={_(msg`Search by domain or organisation name`)}+ value={term}+ onChange={(e) => setTerm(e.target.value)}+ />++ <Select value={statusParam} onValueChange={onStatusChange}>+ <SelectTrigger className="w-[180px]">+ <SelectValue placeholder={_(msg`Filter by status`)} />+ </SelectTrigger>+ <SelectContent>+ <SelectItem value="ALL">+ <Trans>All Statuses</Trans>+ </SelectItem>+ <SelectItem value="PENDING">+ <Trans>Pending</Trans>+ </SelectItem>+ <SelectItem value="ACTIVE">+ <Trans>Active</Trans>+ </SelectItem>+ </SelectContent>+ </Select>+ </div>++ <div className="relative mt-4">+ <DataTable+ columns={columns}+ data={results.data}+ perPage={results.perPage ?? 20}+ currentPage={results.currentPage ?? 1}+ totalPages={results.totalPages ?? 1}+ onPaginationChange={onPaginationChange}+ >+ {(table) => <DataTablePagination additionalInformation="VisibleCount" table={table} />}+ </DataTable>++ {isFindEmailDomainsLoading && (+ <div className="absolute inset-0 flex items-center justify-center bg-white/50">+ <Loader className="h-8 w-8 animate-spin text-gray-500" />+ </div>+ )}+ </div>+ </div>+ </div>+ );+}diff --git a/packages/ee/server-only/lib/create-email-domain.ts b/packages/ee/server-only/lib/create-email-domain.tsindex b50a55965..061a71cc1 100644--- a/packages/ee/server-only/lib/create-email-domain.ts+++ b/packages/ee/server-only/lib/create-email-domain.ts@@ -142,6 +142,7 @@ export const createEmailDomain = async ({ domain, organisationId }: CreateEmailDpublicKey: true,createdAt: true,updatedAt: true,+ lastVerifiedAt: true,emails: true,},});diff --git a/packages/ee/server-only/lib/reregister-email-domain.ts b/packages/ee/server-only/lib/reregister-email-domain.tsnew file mode 100644index 000000000..1b9960c6b--- /dev/null+++ b/packages/ee/server-only/lib/reregister-email-domain.ts@@ -0,0 +1,93 @@+import { DeleteEmailIdentityCommand } from '@aws-sdk/client-sesv2';+import { EmailDomainStatus } from '@prisma/client';++import { DOCUMENSO_ENCRYPTION_KEY } from '@documenso/lib/constants/crypto';+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';+import { symmetricDecrypt } from '@documenso/lib/universal/crypto';+import { prisma } from '@documenso/prisma';++import { getSesClient, verifyDomainWithDKIM } from './create-email-domain';++type ReregisterEmailDomainOptions = {+ emailDomainId: string;+};++/**+ * Re-register an email domain in SES using the same DKIM key pair.+ *+ * This deletes the existing SES identity and recreates it with the same+ * selector and private key, so the user does not need to update their DNS records.+ *+ * Permission is assumed to be checked in the caller.+ */+export const reregisterEmailDomain = async ({ emailDomainId }: ReregisterEmailDomainOptions) => {+ const encryptionKey = DOCUMENSO_ENCRYPTION_KEY;++ if (!encryptionKey) {+ throw new Error('Missing DOCUMENSO_ENCRYPTION_KEY');+ }++ const emailDomain = await prisma.emailDomain.findUnique({+ where: {+ id: emailDomainId,+ },+ });++ if (!emailDomain) {+ throw new AppError(AppErrorCode.NOT_FOUND, {+ message: 'Email domain not found',+ });+ }++ const sesClient = getSesClient();++ // Delete the existing SES identity, ignoring if it no longer exists.+ await sesClient+ .send(+ new DeleteEmailIdentityCommand({+ EmailIdentity: emailDomain.domain,+ }),+ )+ .catch((err) => {+ if (err.name === 'NotFoundException') {+ return;+ }++ throw err;+ });++ // Decrypt the stored private key.+ const decryptedPrivateKeyBytes = symmetricDecrypt({+ key: encryptionKey,+ data: emailDomain.privateKey,+ });++ const decryptedPrivateKey = new TextDecoder().decode(decryptedPrivateKeyBytes);++ // The selector field in the DB is the full record name (e.g. "documenso-orgid._domainkey.example.com").+ // We need to extract just the selector part (before "._domainkey.").+ const selectorParts = emailDomain.selector.split('._domainkey.');+ const selector = selectorParts[0];++ if (!selector) {+ throw new AppError(AppErrorCode.UNKNOWN_ERROR, {+ message: 'Could not extract selector from email domain record',+ });+ }++ // Recreate the SES identity with the same DKIM key pair.+ await verifyDomainWithDKIM(emailDomain.domain, selector, decryptedPrivateKey);++ // Reset status to PENDING and update lastVerifiedAt.+ const updatedEmailDomain = await prisma.emailDomain.update({+ where: {+ id: emailDomainId,+ },+ data: {+ status: EmailDomainStatus.PENDING,+ lastVerifiedAt: new Date(),+ },+ });++ return updatedEmailDomain;+};diff --git a/packages/ee/server-only/lib/verify-email-domain.ts b/packages/ee/server-only/lib/verify-email-domain.tsindex 0c898016e..bf82a78da 100644--- a/packages/ee/server-only/lib/verify-email-domain.ts+++ b/packages/ee/server-only/lib/verify-email-domain.ts@@ -35,6 +35,7 @@ export const verifyEmailDomain = async (emailDomainId: string) => {},data: {status: isVerified ? EmailDomainStatus.ACTIVE : EmailDomainStatus.PENDING,+ lastVerifiedAt: new Date(),},});diff --git a/packages/lib/jobs/client.ts b/packages/lib/jobs/client.tsindex 0471e2018..af6241320 100644--- a/packages/lib/jobs/client.ts+++ b/packages/lib/jobs/client.ts@@ -16,6 +16,7 @@ import { EXECUTE_WEBHOOK_JOB_DEFINITION } from './definitions/internal/execute-wimport { EXPIRE_RECIPIENTS_SWEEP_JOB_DEFINITION } from './definitions/internal/expire-recipients-sweep';import { PROCESS_RECIPIENT_EXPIRED_JOB_DEFINITION } from './definitions/internal/process-recipient-expired';import { SEAL_DOCUMENT_JOB_DEFINITION } from './definitions/internal/seal-document';+import { SYNC_EMAIL_DOMAINS_JOB_DEFINITION } from './definitions/internal/sync-email-domains';/*** The `as const` assertion is load bearing as it provides the correct level of type inference for@@ -39,6 +40,7 @@ export const jobsClient = new JobClient([EXPIRE_RECIPIENTS_SWEEP_JOB_DEFINITION,PROCESS_RECIPIENT_EXPIRED_JOB_DEFINITION,CLEANUP_RATE_LIMITS_JOB_DEFINITION,+ SYNC_EMAIL_DOMAINS_JOB_DEFINITION,] as const);export const jobs = jobsClient;diff --git a/packages/lib/jobs/client/inngest.ts b/packages/lib/jobs/client/inngest.tsindex 8b565342b..702fc1de7 100644--- a/packages/lib/jobs/client/inngest.ts+++ b/packages/lib/jobs/client/inngest.ts@@ -26,6 +26,7 @@ export class InngestJobProvider extends BaseJobProvider {const client = new InngestClient({id: env('NEXT_PRIVATE_INNGEST_APP_ID') || 'documenso-app',eventKey: env('INNGEST_EVENT_KEY') || env('NEXT_PRIVATE_INNGEST_EVENT_KEY'),+ logger: console,});this._instance = new InngestJobProvider({ client });@@ -90,7 +91,10 @@ export class InngestJobProvider extends BaseJobProvider {return {wait: step.sleep,logger: {- ...ctx.logger,+ info: ctx.logger.info,+ debug: ctx.logger.debug,+ error: ctx.logger.error,+ warn: ctx.logger.warn,log: ctx.logger.info,},runTask: async (cacheKey, callback) => {diff --git a/packages/lib/jobs/definitions/internal/sync-email-domains.handler.ts b/packages/lib/jobs/definitions/internal/sync-email-domains.handler.tsnew file mode 100644index 000000000..8d580a010--- /dev/null+++ b/packages/lib/jobs/definitions/internal/sync-email-domains.handler.ts@@ -0,0 +1,86 @@+import { DateTime } from 'luxon';++import { reregisterEmailDomain } from '@documenso/ee/server-only/lib/reregister-email-domain';+import { verifyEmailDomain } from '@documenso/ee/server-only/lib/verify-email-domain';+import { prisma } from '@documenso/prisma';++import type { JobRunIO } from '../../client/_internal/job';+import type { TSyncEmailDomainsJobDefinition } from './sync-email-domains';++const BATCH_SIZE = 10;+const AUTO_REREGISTER_AFTER_HOURS = 48;++export const run = async ({ io }: { payload: TSyncEmailDomainsJobDefinition; io: JobRunIO }) => {+ const pendingDomains = await prisma.emailDomain.findMany({+ where: {+ status: 'PENDING',+ },+ select: {+ id: true,+ domain: true,+ createdAt: true,+ lastVerifiedAt: true,+ },+ orderBy: {+ lastVerifiedAt: { sort: 'asc', nulls: 'first' },+ },+ });++ if (pendingDomains.length === 0) {+ io.logger.info('No pending email domains to sync');+ return;+ }++ io.logger.info(`Found ${pendingDomains.length} pending email domains to sync`);++ let verifiedCount = 0;+ let reregisteredCount = 0;+ let errorCount = 0;++ const reregisterCutoff = DateTime.now().minus({ hours: AUTO_REREGISTER_AFTER_HOURS }).toJSDate();++ for (let i = 0; i < pendingDomains.length; i += BATCH_SIZE) {+ const batch = pendingDomains.slice(i, i + BATCH_SIZE);++ const results = await Promise.allSettled(+ batch.map(async (domain) => {+ const shouldReregister = domain.createdAt < reregisterCutoff;++ if (shouldReregister) {+ io.logger.info(+ `Domain "${domain.domain}" has been pending since ${domain.createdAt.toISOString()}, attempting re-registration`,+ );++ await reregisterEmailDomain({ emailDomainId: domain.id });+ return 'reregistered' as const;+ }++ const { isVerified } = await verifyEmailDomain(domain.id);++ return isVerified ? ('verified' as const) : ('pending' as const);+ }),+ );++ for (const result of results) {+ if (result.status === 'rejected') {+ errorCount++;+ io.logger.error(`Failed to process email domain: ${String(result.reason)}`);+ } else if (result.value === 'verified') {+ verifiedCount++;+ } else if (result.value === 'reregistered') {+ reregisteredCount++;+ }+ }++ // Small delay between batches to respect SES API rate limits.+ if (i + BATCH_SIZE < pendingDomains.length) {+ await new Promise<void>((resolve) => {+ setTimeout(resolve, 1000);+ });+ }+ }++ io.logger.info(+ `Sync complete: ${verifiedCount} verified, ${reregisteredCount} re-registered, ${errorCount} errors out of ${pendingDomains.length} pending domains`,+ );+};diff --git a/packages/lib/jobs/definitions/internal/sync-email-domains.ts b/packages/lib/jobs/definitions/internal/sync-email-domains.tsnew file mode 100644index 000000000..f20f3b18d--- /dev/null+++ b/packages/lib/jobs/definitions/internal/sync-email-domains.ts@@ -0,0 +1,30 @@+import { z } from 'zod';++import { type JobDefinition } from '../../client/_internal/job';++const SYNC_EMAIL_DOMAINS_JOB_DEFINITION_ID = 'internal.sync-email-domains';++const SYNC_EMAIL_DOMAINS_JOB_DEFINITION_SCHEMA = z.object({});++export type TSyncEmailDomainsJobDefinition = z.infer<+ typeof SYNC_EMAIL_DOMAINS_JOB_DEFINITION_SCHEMA+>;++export const SYNC_EMAIL_DOMAINS_JOB_DEFINITION = {+ id: SYNC_EMAIL_DOMAINS_JOB_DEFINITION_ID,+ name: 'Sync Email Domains',+ version: '1.0.0',+ trigger: {+ name: SYNC_EMAIL_DOMAINS_JOB_DEFINITION_ID,+ schema: SYNC_EMAIL_DOMAINS_JOB_DEFINITION_SCHEMA,+ cron: '0 * * * *', // Every hour, on the hour.+ },+ handler: async ({ payload, io }) => {+ const handler = await import('./sync-email-domains.handler');++ await handler.run({ payload, io });+ },+} as const satisfies JobDefinition<+ typeof SYNC_EMAIL_DOMAINS_JOB_DEFINITION_ID,+ TSyncEmailDomainsJobDefinition+>;diff --git a/packages/lib/types/email-domain.ts b/packages/lib/types/email-domain.tsindex 2dbf79b2a..df5944bfc 100644--- a/packages/lib/types/email-domain.ts+++ b/packages/lib/types/email-domain.ts@@ -18,6 +18,7 @@ export const ZEmailDomainSchema = EmailDomainSchema.pick({publicKey: true,createdAt: true,updatedAt: true,+ lastVerifiedAt: true,}).extend({emails: ZOrganisationEmailLiteSchema.array(),});@@ -35,6 +36,7 @@ export const ZEmailDomainManySchema = EmailDomainSchema.pick({selector: true,createdAt: true,updatedAt: true,+ lastVerifiedAt: true,});export type TEmailDomainMany = z.infer<typeof ZEmailDomainManySchema>;diff --git a/packages/prisma/migrations/20260224000000_add_email_domain_last_verified_at/migration.sql b/packages/prisma/migrations/20260224000000_add_email_domain_last_verified_at/migration.sqlnew file mode 100644index 000000000..6d2dc6073--- /dev/null+++ b/packages/prisma/migrations/20260224000000_add_email_domain_last_verified_at/migration.sql@@ -0,0 +1,2 @@+-- AlterTable+ALTER TABLE "EmailDomain" ADD COLUMN "lastVerifiedAt" TIMESTAMP(3);diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prismaindex 63a9f6a0e..467be8d2e 100644--- a/packages/prisma/schema.prisma+++ b/packages/prisma/schema.prisma@@ -1037,10 +1037,11 @@ model EmailDomain {status EmailDomainStatus @default(PENDING)- selector String @unique- domain String @unique- publicKey String- privateKey String+ selector String @unique+ domain String @unique+ publicKey String+ privateKey String+ lastVerifiedAt DateTime?organisationId Stringorganisation Organisation @relation(fields: [organisationId], references: [id], onDelete: Cascade)diff --git a/packages/trpc/server/admin-router/find-email-domains.ts b/packages/trpc/server/admin-router/find-email-domains.tsnew file mode 100644index 000000000..5caa8d58e--- /dev/null+++ b/packages/trpc/server/admin-router/find-email-domains.ts@@ -0,0 +1,101 @@+import { Prisma } from '@prisma/client';++import type { FindResultResponse } from '@documenso/lib/types/search-params';+import { prisma } from '@documenso/prisma';++import { adminProcedure } from '../trpc';+import {+ ZFindEmailDomainsRequestSchema,+ ZFindEmailDomainsResponseSchema,+} from './find-email-domains.types';++export const findEmailDomainsRoute = adminProcedure+ .input(ZFindEmailDomainsRequestSchema)+ .output(ZFindEmailDomainsResponseSchema)+ .query(async ({ input }) => {+ const { query, page, perPage, status } = input;++ return await findEmailDomains({ query, page, perPage, status });+ });++type FindEmailDomainsOptions = {+ query?: string;+ page?: number;+ perPage?: number;+ status?: 'PENDING' | 'ACTIVE';+};++const findEmailDomains = async ({+ query,+ page = 1,+ perPage = 20,+ status,+}: FindEmailDomainsOptions) => {+ const whereClause: Prisma.EmailDomainWhereInput = {};++ if (query) {+ whereClause.OR = [+ {+ domain: {+ contains: query,+ mode: Prisma.QueryMode.insensitive,+ },+ },+ {+ organisation: {+ name: {+ contains: query,+ mode: Prisma.QueryMode.insensitive,+ },+ },+ },+ ];+ }++ if (status) {+ whereClause.status = status;+ }++ const [data, count] = await Promise.all([+ prisma.emailDomain.findMany({+ where: whereClause,+ skip: Math.max(page - 1, 0) * perPage,+ take: perPage,+ orderBy: {+ createdAt: 'desc',+ },+ select: {+ id: true,+ domain: true,+ status: true,+ selector: true,+ createdAt: true,+ updatedAt: true,+ lastVerifiedAt: true,+ organisation: {+ select: {+ id: true,+ name: true,+ url: true,+ },+ },+ _count: {+ select: {+ emails: true,+ },+ },+ },+ }),+ prisma.emailDomain.count({+ where: whereClause,+ }),+ ]);++ return {+ data,+ count,+ currentPage: Math.max(page, 1),+ perPage,+ totalPages: Math.ceil(count / perPage),+ } satisfies FindResultResponse<typeof data>;+};diff --git a/packages/trpc/server/admin-router/find-email-domains.types.ts b/packages/trpc/server/admin-router/find-email-domains.types.tsnew file mode 100644index 000000000..c4118436e--- /dev/null+++ b/packages/trpc/server/admin-router/find-email-domains.types.ts@@ -0,0 +1,36 @@+import { z } from 'zod';++import { ZFindResultResponse, ZFindSearchParamsSchema } from '@documenso/lib/types/search-params';+import EmailDomainStatusSchema from '@documenso/prisma/generated/zod/inputTypeSchemas/EmailDomainStatusSchema';+import EmailDomainSchema from '@documenso/prisma/generated/zod/modelSchema/EmailDomainSchema';+import OrganisationSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationSchema';++export const ZFindEmailDomainsRequestSchema = ZFindSearchParamsSchema.extend({+ status: EmailDomainStatusSchema.optional(),+});++export const ZFindEmailDomainsResponseSchema = ZFindResultResponse.extend({+ data: EmailDomainSchema.pick({+ id: true,+ domain: true,+ status: true,+ selector: true,+ createdAt: true,+ updatedAt: true,+ lastVerifiedAt: true,+ })+ .extend({+ organisation: OrganisationSchema.pick({+ id: true,+ name: true,+ url: true,+ }),+ _count: z.object({+ emails: z.number(),+ }),+ })+ .array(),+});++export type TFindEmailDomainsRequest = z.infer<typeof ZFindEmailDomainsRequestSchema>;+export type TFindEmailDomainsResponse = z.infer<typeof ZFindEmailDomainsResponseSchema>;diff --git a/packages/trpc/server/admin-router/get-email-domain.ts b/packages/trpc/server/admin-router/get-email-domain.tsnew file mode 100644index 000000000..b4acf4f69--- /dev/null+++ b/packages/trpc/server/admin-router/get-email-domain.ts@@ -0,0 +1,42 @@+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';+import { prisma } from '@documenso/prisma';++import { adminProcedure } from '../trpc';+import {+ ZGetEmailDomainRequestSchema,+ ZGetEmailDomainResponseSchema,+} from './get-email-domain.types';++export const getEmailDomainRoute = adminProcedure+ .input(ZGetEmailDomainRequestSchema)+ .output(ZGetEmailDomainResponseSchema)+ .query(async ({ input }) => {+ const { emailDomainId } = input;++ const emailDomain = await prisma.emailDomain.findUnique({+ where: {+ id: emailDomainId,+ },+ omit: {+ privateKey: true,+ },+ include: {+ organisation: {+ select: {+ id: true,+ name: true,+ url: true,+ },+ },+ emails: true,+ },+ });++ if (!emailDomain) {+ throw new AppError(AppErrorCode.NOT_FOUND, {+ message: 'Email domain not found',+ });+ }++ return emailDomain;+ });diff --git a/packages/trpc/server/admin-router/get-email-domain.types.ts b/packages/trpc/server/admin-router/get-email-domain.types.tsnew file mode 100644index 000000000..fdfc00810--- /dev/null+++ b/packages/trpc/server/admin-router/get-email-domain.types.ts@@ -0,0 +1,30 @@+import { z } from 'zod';++import { ZOrganisationEmailLiteSchema } from '@documenso/lib/types/organisation-email';+import EmailDomainSchema from '@documenso/prisma/generated/zod/modelSchema/EmailDomainSchema';+import OrganisationSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationSchema';++export const ZGetEmailDomainRequestSchema = z.object({+ emailDomainId: z.string(),+});++export const ZGetEmailDomainResponseSchema = EmailDomainSchema.pick({+ id: true,+ domain: true,+ status: true,+ selector: true,+ publicKey: true,+ createdAt: true,+ updatedAt: true,+ lastVerifiedAt: true,+}).extend({+ organisation: OrganisationSchema.pick({+ id: true,+ name: true,+ url: true,+ }),+ emails: ZOrganisationEmailLiteSchema.array(),+});++export type TGetEmailDomainRequest = z.infer<typeof ZGetEmailDomainRequestSchema>;+export type TGetEmailDomainResponse = z.infer<typeof ZGetEmailDomainResponseSchema>;diff --git a/packages/trpc/server/admin-router/reregister-email-domain.ts b/packages/trpc/server/admin-router/reregister-email-domain.tsnew file mode 100644index 000000000..d334c66e3--- /dev/null+++ b/packages/trpc/server/admin-router/reregister-email-domain.ts@@ -0,0 +1,22 @@+import { reregisterEmailDomain } from '@documenso/ee/server-only/lib/reregister-email-domain';++import { adminProcedure } from '../trpc';+import {+ ZReregisterEmailDomainRequestSchema,+ ZReregisterEmailDomainResponseSchema,+} from './reregister-email-domain.types';++export const reregisterEmailDomainRoute = adminProcedure+ .input(ZReregisterEmailDomainRequestSchema)+ .output(ZReregisterEmailDomainResponseSchema)+ .mutation(async ({ input, ctx }) => {+ const { emailDomainId } = input;++ ctx.logger.info({+ input: {+ emailDomainId,+ },+ });++ await reregisterEmailDomain({ emailDomainId });+ });diff --git a/packages/trpc/server/admin-router/reregister-email-domain.types.ts b/packages/trpc/server/admin-router/reregister-email-domain.types.tsnew file mode 100644index 000000000..de7d222f4--- /dev/null+++ b/packages/trpc/server/admin-router/reregister-email-domain.types.ts@@ -0,0 +1,10 @@+import { z } from 'zod';++export const ZReregisterEmailDomainRequestSchema = z.object({+ emailDomainId: z.string(),+});++export const ZReregisterEmailDomainResponseSchema = z.void();++export type TReregisterEmailDomainRequest = z.infer<typeof ZReregisterEmailDomainRequestSchema>;+export type TReregisterEmailDomainResponse = z.infer<typeof ZReregisterEmailDomainResponseSchema>;diff --git a/packages/trpc/server/admin-router/router.ts b/packages/trpc/server/admin-router/router.tsindex 17783072d..dd472705f 100644--- a/packages/trpc/server/admin-router/router.ts+++ b/packages/trpc/server/admin-router/router.ts@@ -11,11 +11,14 @@ import { findAdminOrganisationsRoute } from './find-admin-organisations';import { findDocumentAuditLogsRoute } from './find-document-audit-logs';import { findDocumentJobsRoute } from './find-document-jobs';import { findDocumentsRoute } from './find-documents';+import { findEmailDomainsRoute } from './find-email-domains';import { findSubscriptionClaimsRoute } from './find-subscription-claims';import { findUserTeamsRoute } from './find-user-teams';import { getAdminOrganisationRoute } from './get-admin-organisation';+import { getEmailDomainRoute } from './get-email-domain';import { getUserRoute } from './get-user';import { promoteMemberToOwnerRoute } from './promote-member-to-owner';+import { reregisterEmailDomainRoute } from './reregister-email-domain';import { resealDocumentRoute } from './reseal-document';import { resetTwoFactorRoute } from './reset-two-factor-authentication';import { resyncLicenseRoute } from './resync-license';@@ -68,5 +71,10 @@ export const adminRouter = router({recipient: {update: updateRecipientRoute,},+ emailDomain: {+ find: findEmailDomainsRoute,+ get: getEmailDomainRoute,+ reregister: reregisterEmailDomainRoute,+ },updateSiteSetting: updateSiteSettingRoute,});diff --git a/packages/trpc/server/enterprise-router/find-organisation-email-domain.ts b/packages/trpc/server/enterprise-router/find-organisation-email-domain.tsindex 6901efb76..e8694fc38 100644--- a/packages/trpc/server/enterprise-router/find-organisation-email-domain.ts+++ b/packages/trpc/server/enterprise-router/find-organisation-email-domain.ts@@ -95,6 +95,7 @@ export const findOrganisationEmailDomains = async ({selector: true,createdAt: true,updatedAt: true,+ lastVerifiedAt: true,_count: {select: {emails: true,