Update domain page

apps/web/src/server/api/routers/domain.ts

@@ -9,6 +9,7 @@ import {
 import { db } from "~/server/db";
 import {
   createDomain,
+  deleteDomain,
   getDomain,
   updateDomain,
 } from "~/server/service/domain-service";
@@ -53,4 +54,11 @@ export const domainRouter = createTRPCRouter({
         openTracking: input.openTracking,
       });
     }),
+
+  deleteDomain: teamProcedure
+    .input(z.object({ id: z.number() }))
+    .mutation(async ({ ctx, input }) => {
+      await deleteDomain(input.id);
+      return { success: true };
+    }),
 });

apps/web/src/server/service/domain-service.ts

@@ -1,15 +1,21 @@
-import { addDomain, getDomainIdentity } from "~/server/ses";
+import dns from "dns";
+import util from "util";
+import * as tldts from "tldts";
+import * as ses from "~/server/ses";
 import { db } from "~/server/db";
 
+const dnsResolveTxt = util.promisify(dns.resolveTxt);
+
 export async function createDomain(teamId: number, name: string) {
-  console.log("Creating domain:", name);
-  const publicKey = await addDomain(name);
+  const subdomain = tldts.getSubdomain(name);
+  const publicKey = await ses.addDomain(name);
 
   const domain = await db.domain.create({
     data: {
       name,
       publicKey,
       teamId,
+      subdomain,
     },
   });
 
@@ -28,7 +34,10 @@ export async function getDomain(id: number) {
   }
 
   if (domain.status !== "SUCCESS") {
-    const domainIdentity = await getDomainIdentity(domain.name, domain.region);
+    const domainIdentity = await ses.getDomainIdentity(
+      domain.name,
+      domain.region
+    );
 
     const dkimStatus = domainIdentity.DkimAttributes?.Status;
     const spfDetails = domainIdentity.MailFromAttributes?.MailFromDomainStatus;
@@ -36,13 +45,17 @@ export async function getDomain(id: number) {
     const verificationStatus = domainIdentity.VerificationStatus;
     const lastCheckedTime =
       domainIdentity.VerificationInfo?.LastCheckedTimestamp;
+    const _dmarcRecord = await getDmarcRecord(domain.name);
+    const dmarcRecord = _dmarcRecord?.[0]?.[0];
 
     console.log(domainIdentity);
+    console.log(dmarcRecord);
 
     if (
       domain.dkimStatus !== dkimStatus ||
       domain.spfDetails !== spfDetails ||
-      domain.status !== verificationStatus
+      domain.status !== verificationStatus ||
+      domain.dmarcAdded !== (dmarcRecord ? true : false)
     ) {
       domain = await db.domain.update({
         where: {
@@ -52,16 +65,18 @@ export async function getDomain(id: number) {
           dkimStatus,
           spfDetails,
           status: verificationStatus ?? "NOT_STARTED",
+          dmarcAdded: dmarcRecord ? true : false,
         },
       });
     }
 
     return {
       ...domain,
-      dkimStatus,
-      spfDetails,
-      verificationError,
+      dkimStatus: dkimStatus?.toString() ?? null,
+      spfDetails: spfDetails?.toString() ?? null,
+      verificationError: verificationError?.toString() ?? null,
       lastCheckedTime,
+      dmarcAdded: dmarcRecord ? true : false,
     };
   }
 
@@ -77,3 +92,33 @@ export async function updateDomain(
     data,
   });
 }
+
+export async function deleteDomain(id: number) {
+  const domain = await db.domain.findUnique({
+    where: { id },
+  });
+
+  if (!domain) {
+    throw new Error("Domain not found");
+  }
+
+  const deleted = await ses.deleteDomain(domain.name, domain.region);
+
+  if (!deleted) {
+    throw new Error("Error in deleting domain");
+  }
+
+  return db.domain.delete({
+    where: { id },
+  });
+}
+
+async function getDmarcRecord(domain: string) {
+  try {
+    const dmarcRecord = await dnsResolveTxt(`_dmarc.${domain}`);
+    return dmarcRecord;
+  } catch (error) {
+    console.error("Error fetching DMARC record:", error);
+    return null; // or handle error as appropriate
+  }
+}

apps/web/src/server/ses.ts

@@ -66,7 +66,7 @@ export async function addDomain(domain: string, region = "us-east-1") {
 
   const emailIdentityCommand = new PutEmailIdentityMailFromAttributesCommand({
     EmailIdentity: domain,
-    MailFromDomain: `send.${domain}`,
+    MailFromDomain: `mail.${domain}`,
   });
 
   const emailIdentityResponse = await sesClient.send(emailIdentityCommand);
@@ -75,12 +75,23 @@ export async function addDomain(domain: string, region = "us-east-1") {
     response.$metadata.httpStatusCode !== 200 ||
     emailIdentityResponse.$metadata.httpStatusCode !== 200
   ) {
-    throw new Error("Failed to create email identity");
+    console.log(response);
+    console.log(emailIdentityResponse);
+    throw new Error("Failed to create domain identity");
   }
 
   return publicKey;
 }
 
+export async function deleteDomain(domain: string, region = "us-east-1") {
+  const sesClient = getSesClient(region);
+  const command = new DeleteEmailIdentityCommand({
+    EmailIdentity: domain,
+  });
+  const response = await sesClient.send(command);
+  return response.$metadata.httpStatusCode === 200;
+}
+
 export async function getDomainIdentity(domain: string, region = "us-east-1") {
   const sesClient = getSesClient(region);
   const command = new GetEmailIdentityCommand({
@@ -165,7 +176,6 @@ export async function addWebhookConfiguration(
     ConfigurationSetName: configName, // required
     EventDestinationName: "unsend_destination", // required
     EventDestination: {
-      // EventDestinationDefinition
       Enabled: true,
       MatchingEventTypes: eventTypes,
       SnsDestination: {