Domains, messages, attachments, tests

api/controllers/DNSController.ts

@@ -0,0 +1,15 @@
+import { resolveMx } from 'node:dns/promises';
+import type { MxRecord } from 'node:dns';
+
+export async function getDNSMXRecords({
+  domain,
+}: {
+  domain: string;
+}): Promise<MxRecord[]> {
+  try {
+    return await resolveMx(domain);
+  } catch (error) {
+    console.error('Error resolving MX records:', error);
+    return [];
+  }
+}

api/controllers/DomainController.ts

@@ -0,0 +1,98 @@
+import mongoose, { type HydratedDocument } from "mongoose";
+import Domain from "../db/mongo/schemas/Domain";
+import { getDNSMXRecords } from "./DNSController";
+import type IDomain from "../models/Domain";
+
+export async function createDomain({
+  organizationId,
+  name,
+}: {
+  organizationId: string;
+  name: string;
+}) {
+  const domain = new Domain();
+  domain.organizationId = new mongoose.Types.ObjectId(organizationId);
+  domain.name = name;
+  await domain.save();
+  return domain;
+}
+
+export async function getDomainsByOrganizationId({
+  organizationId,
+}: {
+  organizationId: string;
+}) {
+  return await Domain.find({
+    organizationId: new mongoose.Types.ObjectId(organizationId),
+  });
+}
+
+export async function getDomainByOrganizationIdAndName({
+  organizationId,
+  name,
+}: {
+  organizationId: string;
+  name: string;
+}) {
+  return await Domain.findOne({
+    organizationId: new mongoose.Types.ObjectId(organizationId),
+    name,
+  });
+}
+
+export async function getVerifiedDomainByOrganizationIdAndName({
+  organizationId,
+  name,
+}: {
+  organizationId: string;
+  name: string;
+}) {
+  return await Domain.findOne({
+    organizationId: new mongoose.Types.ObjectId(organizationId),
+    name: name,
+    verified: true,
+  });
+}
+
+export async function deleteDomainByOrganizationIdAndName({
+  organizationId,
+  name,
+}: {
+  organizationId: string;
+  name: string;
+}) {
+  return await Domain.findOneAndDelete({
+    organizationId: new mongoose.Types.ObjectId(organizationId),
+    name: name,
+  });
+}
+
+export async function verifyDomainDNS({
+  domain,
+}: {
+  domain: HydratedDocument<IDomain>;
+}): Promise<{ verified: boolean; domain: HydratedDocument<IDomain> }> {
+  const mxRecords = await getDNSMXRecords({ domain: domain.name });
+
+  let mxRecordFound;
+  if (mxRecords && Array.isArray(mxRecords)) {
+    mxRecordFound = domain.records.find(
+      (domainRecord) =>
+        domainRecord.type === "MX" &&
+        mxRecords.find((dnsRecord) => {
+          return (
+            typeof dnsRecord.exchange === "string" &&
+            dnsRecord.exchange.toLowerCase() === domainRecord.value.toLowerCase()
+          );
+        })
+    );
+  }
+
+  if (mxRecordFound) {
+    mxRecordFound.status = "verified";
+  }
+  domain.verified = mxRecordFound ? true : false;
+  await domain.save();
+
+  return { verified: domain.verified, domain };
+}

api/controllers/InboxController.ts

@@ -42,6 +42,19 @@ export async function getInboxByOrganizationIdAndInboxId({
   });
 }
 
+export async function deleteInboxByOrganizationIdAndInboxId({
+  organizationId,
+  inboxId,
+}: {
+  organizationId: string;
+  inboxId: string;
+}) {
+  return await Inbox.findOneAndDelete({
+    organizationId: new mongoose.Types.ObjectId(organizationId),
+    _id: new mongoose.Types.ObjectId(inboxId),
+  });
+}
+
 export async function getInboxByEmail(email: string) {
   return await Inbox.findOne({ email });
 }

api/controllers/MessageController.ts

@@ -10,10 +10,14 @@ export async function createMessage({
   toInboxId,
   from,
   to,
+  cc,
+  bcc,
+  labels,
   externalMessageId,
   subject,
   text,
   html,
+  attachments,
   status,
 }: {
   organizationId: string;
@@ -22,25 +26,54 @@ export async function createMessage({
   fromInboxId?: string;
   toInboxId?: string;
   from: string;
-  to: string;
+  to?: string[];
+  cc?: string[];
+  bcc?: string[];
+  labels?: string[];
   externalMessageId?: string;
   subject: string;
   text: string;
   html: string;
+  attachments?: {
+    content: string;
+    name?: string;
+    contentType?: string;
+  }[];
   status?: (typeof MessageStatus)[number];
 }) {
   const message = new Message();
   message.organizationId = new mongoose.Types.ObjectId(organizationId);
   message.inboxId = new mongoose.Types.ObjectId(inboxId);
   message.threadId = new mongoose.Types.ObjectId(threadId);
-  message.fromInboxId = fromInboxId ? new mongoose.Types.ObjectId(fromInboxId) : undefined;
-  message.toInboxId = toInboxId ? new mongoose.Types.ObjectId(toInboxId) : undefined;
+  message.fromInboxId = fromInboxId
+    ? new mongoose.Types.ObjectId(fromInboxId)
+    : undefined;
+  message.toInboxId = toInboxId
+    ? new mongoose.Types.ObjectId(toInboxId)
+    : undefined;
   message.from = from;
-  message.to = to;
+  message.to = to ?? [];
+  message.cc = cc ?? [];
+  message.bcc = bcc ?? [];
+  message.labels = labels ?? [];
   message.externalMessageId = externalMessageId;
   message.subject = subject;
   message.text = text;
   message.html = html;
+  message.attachments = new mongoose.Types.Array<{
+    content: string;
+    name?: string;
+    contentType?: string;
+  }>();
+  if (attachments) {
+    for (const attachment of attachments) {
+      message.attachments.push({
+        content: attachment.content,
+        name: attachment.name,
+        contentType: attachment.contentType,
+      });
+    }
+  }
   message.status = status;
   await message.save();
   return message;
@@ -50,10 +83,42 @@ export async function getMessageById(messageId: string) {
   return await Message.findById(messageId);
 }
 
-export async function getMessagesByInboxId(inboxId: string) {
-  return await Message.find({ inboxId: new mongoose.Types.ObjectId(inboxId) });
+export async function getMessages({
+  inboxId,
+  query,
+}: {
+  inboxId: string;
+  query?: string;
+}) {
+  const filter: any = {
+    inboxId: new mongoose.Types.ObjectId(inboxId),
+  };
+
+  if (query) {
+    filter.$or = [
+      { subject: { $regex: query, $options: "i" } },
+      { text: { $regex: query, $options: "i" } },
+      { html: { $regex: query, $options: "i" } },
+      { to: { $regex: query, $options: "i" } },
+      { cc: { $regex: query, $options: "i" } },
+      { bcc: { $regex: query, $options: "i" } },
+      { labels: { $regex: query, $options: "i" } },
+    ];
+  }
+
+  return await Message.find(filter);
 }
 
 export async function getMessageByExternalMessageId(externalMessageId: string) {
   return await Message.findOne({ externalMessageId });
 }
+
+export async function deleteMessageById(messageId: string) {
+  return await Message.findByIdAndDelete(messageId);
+}
+
+export async function deleteMessagesByInboxId(inboxId: string) {
+  return await Message.deleteMany({
+    inboxId: new mongoose.Types.ObjectId(inboxId),
+  });
+}

api/controllers/SESController.ts

@@ -1,9 +1,10 @@
 import {
   GetIdentityDkimAttributesCommand,
-  SendEmailCommand,
+  SendRawEmailCommand,
   SESClient,
   VerifyDomainDkimCommand,
 } from "@aws-sdk/client-ses";
+import MailComposer from "nodemailer/lib/mail-composer";
 import type { SNSMessage } from "../models/SES";
 import { createMessage, getMessageByExternalMessageId, getMessageById } from "./MessageController";
 import type { MessageStatus } from "../models/Message";
@@ -38,46 +39,68 @@ export async function sendSESMessage({
   from,
   fromName,
   to,
+  cc,
+  bcc,
   subject,
   text,
   html,
+  attachments,
 }: {
   messageId: string;
   from: string;
   fromName?: string;
-  to: string;
+  to?: string[];
+  cc?: string[];
+  bcc?: string[];
   subject: string;
   text: string;
   html: string;
+  attachments?: {
+    content: string;
+    name?: string;
+    contentType?: string;
+  }[];
 }) {
-  const command = new SendEmailCommand({
-    Source: fromName ? `${fromName} <${from}>` : from,
-    Destination: {
-      ToAddresses: [to],
-    },
-    Message: {
-      Subject: {
-        Data: subject,
-        Charset: "UTF-8",
-      },
-      Body: {
-        Html: {
-          Data: html,
-          Charset: "UTF-8",
-        },
-        Text: {
-          Data: text,
-          Charset: "UTF-8",
-        },
-      },
+  // SES SendEmailCommand does NOT support attachments. To include attachments, you must use SendRawEmailCommand and manually build a MIME-encoded message.
+  // Here's one way to do it with attachments:
+
+  // Create the MIME message using nodemailer's MailComposer
+  const mailOptions: any = {
+    from: fromName ? `"${fromName}" <${from}>` : from,
+    to: (to ?? []).join(", "),
+    cc: (cc ?? []).join(", "),
+    bcc: (bcc ?? []).join(", "),
+    subject,
+    text,
+    html,
+    attachments: (attachments ?? []).map(att => ({
+      filename: att.name,
+      content: att.content,
+      contentType: att.contentType,
+      encoding: "base64",
+    })),
+    headers: {
+      "X-SES-CONFIGURATION-SET": "sendook-config-set",
+      "X-SES-MESSAGE-TAGS": `message=${messageId}`,
     },
+  };
+
+  const composer = new MailComposer(mailOptions);
+  const mimeMessage = await new Promise<Buffer>((resolve, reject) => {
+    composer.compile().build((err, message) => {
+      if (err) return reject(err);
+      resolve(message);
+    });
+  });
+
+  const command = new SendRawEmailCommand({
+    RawMessage: { Data: mimeMessage },
     Tags: [
       {
         Name: "message",
         Value: messageId,
       },
     ],
-    ConfigurationSetName: "sendook-config-set",
   });
   return await ses.send(command);
 }
@@ -150,7 +173,7 @@ export async function handleInboundSESMessage({
     threadId,
     from: notification.mail.source,
     fromInboxId: fromInboxId?.id,
-    to: notification.mail.destination[0],
+    to: [notification.mail.destination[0]],
     toInboxId: inbox.id,
     subject: notification.mail.commonHeaders?.subject,
     text: content.getVisibleText(),

api/db/mongo/schemas/Domain.ts

@@ -16,10 +16,23 @@ const domainSchema = new mongoose.Schema(
       type: Boolean,
       default: false,
     },
+    records: {
+      type: [mongoose.Schema.Types.Mixed],
+      default: [
+        {
+          type: "MX",
+          name: "@",
+          value: "inbound-smtp.us-east-2.amazonaws.com",
+          status: "pending",
+        },
+      ],
+    },
   },
   {
     timestamps: true,
   }
 );
 
+domainSchema.index({ organizationId: 1, name: 1 }, { unique: true });
+
 export default mongoose.model<IDomain>("Domain", domainSchema);