gib/GibSend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: expose domain dns records via api (#259)

Browse Source
This commit is contained in:
KM Koushik
2025-09-27 09:40:14 +10:00
committed by GitHub
parent 014199201b
commit 76fdad6c81
25 changed files with 2066 additions and 551 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/web/src/app/(dashboard)/domains/[domainId]/page.tsx
+41 -96
View File
@@ -1,7 +1,7 @@
"use client";
import { api } from "~/trpc/react";
import { Domain, DomainStatus } from "@prisma/client";
import { DomainStatus } from "@prisma/client";
import {
Breadcrumb,
BreadcrumbItem,
@@ -27,7 +27,11 @@ import SendTestMail from "./send-test-mail";
import { Button } from "@usesend/ui/src/button";
import Link from "next/link";
import { toast } from "@usesend/ui/src/toaster";
import { H1 } from "@usesend/ui";
import type { inferRouterOutputs } from "@trpc/server";
import type { AppRouter } from "~/server/api/root";
type RouterOutputs = inferRouterOutputs<AppRouter>;
type DomainResponse = NonNullable<RouterOutputs["domain"]["getDomain"]>;
export default function DomainItemPage({
params,
@@ -124,98 +128,39 @@ export default function DomainItemPage({
</TableRow>
</TableHeader>
<TableBody>
<TableRow>
<TableCell className="">MX</TableCell>
<TableCell>
<TextWithCopyButton
value={`mail${domainQuery.data?.subdomain ? `.${domainQuery.data.subdomain}` : ""}`}
/>
</TableCell>
<TableCell className="">
<TextWithCopyButton
value={`feedback-smtp.${domainQuery.data?.region}.amazonses.com`}
className="w-[200px] overflow-hidden text-ellipsis text-nowrap"
/>
{/* <div className="w-[200px] overflow-hidden text-ellipsis text-nowrap">
{`feedback-smtp.${domainQuery.data?.region}.amazonses.com`}
</div> */}
</TableCell>
<TableCell className="">Auto</TableCell>
<TableCell className="">10</TableCell>
<TableCell className="">
<DnsVerificationStatus
status={domainQuery.data?.spfDetails ?? "NOT_STARTED"}
/>
</TableCell>
</TableRow>
<TableRow>
<TableCell className="">TXT</TableCell>
<TableCell>
<TextWithCopyButton
value={`${domainQuery.data?.dkimSelector ?? "unsend"}._domainkey${domainQuery.data?.subdomain ? `.${domainQuery.data.subdomain}` : ""}`}
/>
</TableCell>
<TableCell className="">
<TextWithCopyButton
value={`p=${domainQuery.data?.publicKey}`}
className="w-[200px] overflow-hidden text-ellipsis"
/>
</TableCell>
<TableCell className="">Auto</TableCell>
<TableCell className=""></TableCell>
<TableCell className="">
<DnsVerificationStatus
status={domainQuery.data?.dkimStatus ?? "NOT_STARTED"}
/>
</TableCell>
</TableRow>
<TableRow>
<TableCell className="">TXT</TableCell>
<TableCell>
<TextWithCopyButton
value={`mail${domainQuery.data?.subdomain ? `.${domainQuery.data.subdomain}` : ""}`}
/>
</TableCell>
<TableCell className="">
<TextWithCopyButton
value={`v=spf1 include:amazonses.com ~all`}
className="w-[200px] overflow-hidden text-ellipsis text-nowrap"
/>
</TableCell>
<TableCell className="">Auto</TableCell>
<TableCell className=""></TableCell>
<TableCell className="">
<DnsVerificationStatus
status={domainQuery.data?.spfDetails ?? "NOT_STARTED"}
/>
</TableCell>
</TableRow>
<TableRow>
<TableCell className="">TXT</TableCell>
<TableCell>
<div className="flex gap-2 items-center">
<span className="text-sm text-muted-foreground">
(recommended)
</span>
<TextWithCopyButton value="_dmarc" />
</div>
</TableCell>
<TableCell className="">
<TextWithCopyButton
value={`v=DMARC1; p=none;`}
className="w-[200px] overflow-hidden text-ellipsis text-nowrap"
/>
</TableCell>
<TableCell className="">Auto</TableCell>
<TableCell className=""></TableCell>
<TableCell className="">
<DnsVerificationStatus
status={
domainQuery.data?.dmarcAdded ? "SUCCESS" : "NOT_STARTED"
}
/>
</TableCell>
</TableRow>
{(domainQuery.data?.dnsRecords ?? []).map((record) => {
const key = `${record.type}-${record.name}`;
const valueClassName = record.name.includes("_domainkey")
? "w-[200px] overflow-hidden text-ellipsis"
: "w-[200px] overflow-hidden text-ellipsis text-nowrap";
return (
<TableRow key={key}>
<TableCell className="">{record.type}</TableCell>
<TableCell>
<div className="flex gap-2 items-center">
{record.recommended ? (
<span className="text-sm text-muted-foreground">
(recommended)
</span>
) : null}
<TextWithCopyButton value={record.name} />
</div>
</TableCell>
<TableCell className="">
<TextWithCopyButton
value={record.value}
className={valueClassName}
/>
</TableCell>
<TableCell className="">{record.ttl}</TableCell>
<TableCell className="">{record.priority ?? ""}</TableCell>
<TableCell className="">
<DnsVerificationStatus status={record.status} />
</TableCell>
</TableRow>
);
})}
</TableBody>
</Table>
</div>
@@ -228,7 +173,7 @@ export default function DomainItemPage({
);
}
const DomainSettings: React.FC<{ domain: Domain }> = ({ domain }) => {
const DomainSettings: React.FC<{ domain: DomainResponse }> = ({ domain }) => {
const updateDomain = api.domain.updateDomain.useMutation();
const utils = api.useUtils();
@@ -303,7 +248,7 @@ const DomainSettings: React.FC<{ domain: Domain }> = ({ domain }) => {
);
};
const DnsVerificationStatus: React.FC<{ status: string }> = ({ status }) => {
const DnsVerificationStatus: React.FC<{ status: DomainStatus }> = ({ status }) => {
let badgeColor = "bg-gray/10 text-gray border-gray/10"; // Default color
switch (status) {
case DomainStatus.SUCCESS:
apps/web/src/app/(dashboard)/domains/[domainId]/send-test-mail.tsx
+4 -2
View File
@@ -3,12 +3,14 @@
import { Button } from "@usesend/ui/src/button";
import { api } from "~/trpc/react";
import React from "react";
import { Domain } from "@prisma/client";
import { toast } from "@usesend/ui/src/toaster";
import { SendHorizonal } from "lucide-react";
import type { DomainWithDnsRecords } from "~/types/domain";
// Removed dialog and example code. Clicking the button now sends the email directly.
export const SendTestMail: React.FC<{ domain: Domain }> = ({ domain }) => {
export const SendTestMail: React.FC<{ domain: DomainWithDnsRecords }> = ({
domain,
}) => {
const sendTestEmailFromDomainMutation =
api.domain.sendTestEmailFromDomain.useMutation();
apps/web/src/lib/zod/domain-schema.ts
+31
View File
@@ -3,6 +3,34 @@ import { z } from "zod";
export const DomainStatusSchema = z.nativeEnum(DomainStatus);
export const DomainDnsRecordSchema = z.object({
type: z.enum(["MX", "TXT"]).openapi({
description: "DNS record type",
example: "TXT",
}),
name: z
.string()
.openapi({ description: "DNS record name", example: "mail" }),
value: z
.string()
.openapi({
description: "DNS record value",
example: "v=spf1 include:amazonses.com ~all",
}),
ttl: z
.string()
.openapi({ description: "DNS record TTL", example: "Auto" }),
priority: z
.string()
.nullish()
.openapi({ description: "DNS record priority", example: "10" }),
status: DomainStatusSchema,
recommended: z
.boolean()
.optional()
.openapi({ description: "Whether the record is recommended" }),
});
export const DomainSchema = z.object({
id: z.number().openapi({ description: "The ID of the domain", example: 1 }),
name: z
@@ -22,4 +50,7 @@ export const DomainSchema = z.object({
isVerifying: z.boolean().default(false),
errorMessage: z.string().optional().nullish(),
subdomain: z.string().optional().nullish(),
verificationError: z.string().optional().nullish(),
lastCheckedTime: z.string().optional().nullish(),
dnsRecords: z.array(DomainDnsRecordSchema),
});
apps/web/src/server/api/routers/domain.ts
+7 -15
View File
@@ -11,6 +11,7 @@ import {
createDomain,
deleteDomain,
getDomain,
getDomains,
updateDomain,
} from "~/server/service/domain-service";
import { sendEmail } from "~/server/service/email-service";
@@ -29,7 +30,7 @@ export const domainRouter = createTRPCRouter({
ctx.team.id,
input.name,
input.region,
ctx.team.sesTenantId ?? undefined,
ctx.team.sesTenantId ?? undefined
);
}),
@@ -41,20 +42,11 @@ export const domainRouter = createTRPCRouter({
}),
domains: teamProcedure.query(async ({ ctx }) => {
const domains = await db.domain.findMany({
where: {
teamId: ctx.team.id,
},
orderBy: {
createdAt: "desc",
},
});
return domains;
return getDomains(ctx.team.id);
}),
getDomain: domainProcedure.query(async ({ input }) => {
return getDomain(input.id);
getDomain: domainProcedure.query(async ({ input, ctx }) => {
return getDomain(input.id, ctx.team.id);
}),
updateDomain: domainProcedure
@@ -62,7 +54,7 @@ export const domainRouter = createTRPCRouter({
z.object({
clickTracking: z.boolean().optional(),
openTracking: z.boolean().optional(),
}),
})
)
.mutation(async ({ input }) => {
return updateDomain(input.id, {
@@ -104,6 +96,6 @@ export const domainRouter = createTRPCRouter({
text: "hello,\n\nuseSend is the best open source sending platform\n\ncheck out https://usesend.com",
html: "<p>hello,</p><p>useSend is the best open source sending platform<p><p>check out <a href='https://usesend.com'>usesend.com</a>",
});
},
}
),
});
apps/web/src/server/public-api/api/domains/create-domain.ts
-1
View File
@@ -2,7 +2,6 @@ import { createRoute, z } from "@hono/zod-openapi";
import { DomainSchema } from "~/lib/zod/domain-schema";
import { PublicAPIApp } from "~/server/public-api/hono";
import { createDomain as createDomainService } from "~/server/service/domain-service";
import { getTeamFromToken } from "~/server/public-api/auth";
const route = createRoute({
method: "post",
apps/web/src/server/public-api/api/domains/get-domain.ts
+59
View File
@@ -0,0 +1,59 @@
import { createRoute, z } from "@hono/zod-openapi";
import { DomainSchema } from "~/lib/zod/domain-schema";
import { PublicAPIApp } from "~/server/public-api/hono";
import { UnsendApiError } from "../../api-error";
import { db } from "~/server/db";
import { getDomain as getDomainService } from "~/server/service/domain-service";
const route = createRoute({
method: "get",
path: "/v1/domains/{id}",
request: {
params: z.object({
id: z.coerce.number().openapi({
param: { name: "id", in: "path" },
example: 1,
}),
}),
},
responses: {
200: {
content: {
"application/json": {
schema: DomainSchema,
},
},
description: "Retrieve the domain",
},
},
});
function getDomain(app: PublicAPIApp) {
app.openapi(route, async (c) => {
const team = c.var.team;
const id = c.req.valid("param").id;
// Enforce API key domain restriction (if any)
if (team.apiKey.domainId && team.apiKey.domainId !== id) {
throw new UnsendApiError({
code: "NOT_FOUND",
message: "Domain not found",
});
}
// Re-use service logic to enrich domain (verification status, DNS records, etc.)
let enriched;
try {
enriched = await getDomainService(id, team.id);
} catch (e) {
throw new UnsendApiError({
code: "INTERNAL_SERVER_ERROR",
message: e instanceof Error ? e.message : "Internal server error",
});
}
return c.json(enriched);
});
}
export default getDomain;
apps/web/src/server/public-api/api/domains/get-domains.ts
+4 -6
View File
@@ -1,7 +1,7 @@
import { createRoute, z } from "@hono/zod-openapi";
import { DomainSchema } from "~/lib/zod/domain-schema";
import { PublicAPIApp } from "~/server/public-api/hono";
import { db } from "~/server/db";
import { getDomains as getDomainsService } from "~/server/service/domain-service";
const route = createRoute({
method: "get",
@@ -23,11 +23,9 @@ function getDomains(app: PublicAPIApp) {
const team = c.var.team;
// If API key is restricted to a specific domain, only return that domain; else return all team domains
const domains = team.apiKey.domainId
? await db.domain.findMany({
where: { teamId: team.id, id: team.apiKey.domainId },
})
: await db.domain.findMany({ where: { teamId: team.id } });
const domains = await getDomainsService(team.id, {
domainId: team.apiKey.domainId ?? undefined,
});
return c.json(domains);
});
apps/web/src/server/public-api/index.ts
+2
View File
@@ -13,6 +13,7 @@ import upsertContact from "./api/contacts/upsert-contact";
import createDomain from "./api/domains/create-domain";
import deleteContact from "./api/contacts/delete-contact";
import verifyDomain from "./api/domains/verify-domain";
import getDomain from "./api/domains/get-domain";
import sendBatch from "./api/emails/batch-email";
export const app = getApp();
@@ -21,6 +22,7 @@ export const app = getApp();
getDomains(app);
createDomain(app);
verifyDomain(app);
getDomain(app);
/**Email related APIs */
getEmail(app);
apps/web/src/server/service/domain-service.ts
+109 -13
View File
@@ -6,8 +6,79 @@ import { db } from "~/server/db";
import { SesSettingsService } from "./ses-settings-service";
import { UnsendApiError } from "../public-api/api-error";
import { logger } from "../logger/log";
import { ApiKey } from "@prisma/client";
import { ApiKey, DomainStatus, type Domain } from "@prisma/client";
import { LimitService } from "./limit-service";
import type { DomainDnsRecord } from "~/types/domain";
const DOMAIN_STATUS_VALUES = new Set(Object.values(DomainStatus));
function parseDomainStatus(status?: string | null): DomainStatus {
if (!status) {
return DomainStatus.NOT_STARTED;
}
const normalized = status.toUpperCase();
if (DOMAIN_STATUS_VALUES.has(normalized as DomainStatus)) {
return normalized as DomainStatus;
}
return DomainStatus.NOT_STARTED;
}
function buildDnsRecords(domain: Domain): DomainDnsRecord[] {
const subdomainSuffix = domain.subdomain ? `.${domain.subdomain}` : "";
const mailDomain = `mail${subdomainSuffix}`;
const dkimSelector = domain.dkimSelector ?? "usesend";
const spfStatus = parseDomainStatus(domain.spfDetails);
const dkimStatus = parseDomainStatus(domain.dkimStatus);
const dmarcStatus = domain.dmarcAdded
? DomainStatus.SUCCESS
: DomainStatus.NOT_STARTED;
return [
{
type: "MX",
name: mailDomain,
value: `feedback-smtp.${domain.region}.amazonses.com`,
ttl: "Auto",
priority: "10",
status: spfStatus,
},
{
type: "TXT",
name: `${dkimSelector}._domainkey${subdomainSuffix}`,
value: `p=${domain.publicKey}`,
ttl: "Auto",
status: dkimStatus,
},
{
type: "TXT",
name: mailDomain,
value: "v=spf1 include:amazonses.com ~all",
ttl: "Auto",
status: spfStatus,
},
{
type: "TXT",
name: "_dmarc",
value: "v=DMARC1; p=none;",
ttl: "Auto",
status: dmarcStatus,
recommended: true,
},
];
}
function withDnsRecords<T extends Domain>(
domain: T
): T & { dnsRecords: DomainDnsRecord[] } {
return {
...domain,
dnsRecords: buildDnsRecords(domain),
};
}
const dnsResolveTxt = util.promisify(dns.resolveTxt);
@@ -63,12 +134,12 @@ export async function validateApiKeyDomainAccess(
) {
// First validate the domain exists and is verified
const domain = await validateDomainFromEmail(email, teamId);
// If API key has no domain restriction (domainId is null), allow all domains
if (!apiKey.domainId) {
return domain;
}
// If API key is restricted to a specific domain, check if it matches
if (apiKey.domainId !== domain.id) {
throw new UnsendApiError({
@@ -76,7 +147,7 @@ export async function validateApiKeyDomainAccess(
message: `API key does not have access to domain: ${domain.name}`,
});
}
return domain;
}
@@ -128,21 +199,27 @@ export async function createDomain(
region,
sesTenantId,
dkimSelector,
dkimStatus: DomainStatus.NOT_STARTED,
spfDetails: DomainStatus.NOT_STARTED,
},
});
return domain;
return withDnsRecords(domain);
}
export async function getDomain(id: number) {
export async function getDomain(id: number, teamId: number) {
let domain = await db.domain.findUnique({
where: {
id,
teamId,
},
});
if (!domain) {
throw new Error("Domain not found");
throw new UnsendApiError({
code: "NOT_FOUND",
message: "Domain not found",
});
}
if (domain.isVerifying) {
@@ -178,17 +255,30 @@ export async function getDomain(id: number) {
},
});
return {
const normalizedDomain = {
...domain,
dkimStatus: dkimStatus?.toString() ?? null,
spfDetails: spfDetails?.toString() ?? null,
verificationError: verificationError?.toString() ?? null,
lastCheckedTime,
dmarcAdded: dmarcRecord ? true : false,
} satisfies Domain;
const domainWithDns = withDnsRecords(normalizedDomain);
const normalizedLastCheckedTime =
lastCheckedTime instanceof Date
? lastCheckedTime.toISOString()
: (lastCheckedTime ?? null);
return {
...domainWithDns,
dkimStatus: normalizedDomain.dkimStatus,
spfDetails: normalizedDomain.spfDetails,
verificationError: verificationError?.toString() ?? null,
lastCheckedTime: normalizedLastCheckedTime,
dmarcAdded: normalizedDomain.dmarcAdded,
};
}
return domain;
return withDnsRecords(domain);
}
export async function updateDomain(
@@ -225,15 +315,21 @@ export async function deleteDomain(id: number) {
return deletedRecord;
}
export async function getDomains(teamId: number) {
return db.domain.findMany({
export async function getDomains(
teamId: number,
options?: { domainId?: number }
) {
const domains = await db.domain.findMany({
where: {
teamId,
...(options?.domainId ? { id: options.domainId } : {}),
},
orderBy: {
createdAt: "desc",
},
});
return domains.map((d) => withDnsRecords(d));
}
async function getDmarcRecord(domain: string) {
apps/web/src/types/domain.ts
+17
View File
@@ -0,0 +1,17 @@
import type { Domain, DomainStatus } from "@prisma/client";
export type DomainDnsRecord = {
type: "MX" | "TXT";
name: string;
value: string;
ttl: string;
priority?: string | null;
status: DomainStatus;
recommended?: boolean;
};
export type DomainWithDnsRecords = Domain & {
dnsRecords: DomainDnsRecord[];
verificationError?: string | null;
lastCheckedTime?: Date | string | null;
};