Add unsend campaign feature (#45)

* Add unsend email editor

Add email editor

Add more email editor

Add renderer partial

Add more marketing email features

* Add more campaign feature

* Add variables

* Getting there

* campaign is there mfs

* Add migration

apps/web/src/server/api/root.ts

@@ -4,6 +4,8 @@ import { apiRouter } from "./routers/api";
 import { emailRouter } from "./routers/email";
 import { teamRouter } from "./routers/team";
 import { adminRouter } from "./routers/admin";
+import { contactsRouter } from "./routers/contacts";
+import { campaignRouter } from "./routers/campaign";
 
 /**
  * This is the primary router for your server.
@@ -16,6 +18,8 @@ export const appRouter = createTRPCRouter({
   email: emailRouter,
   team: teamRouter,
   admin: adminRouter,
+  contacts: contactsRouter,
+  campaign: campaignRouter,
 });
 
 // export type definition of API

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

@@ -26,12 +26,32 @@ export const adminRouter = createTRPCRouter({
       z.object({
         region: z.string(),
         unsendUrl: z.string().url(),
+        sendRate: z.number(),
+        transactionalQuota: z.number(),
       })
     )
     .mutation(async ({ input }) => {
       return SesSettingsService.createSesSetting({
         region: input.region,
         unsendUrl: input.unsendUrl,
+        sendingRateLimit: input.sendRate,
+        transactionalQuota: input.transactionalQuota,
+      });
+    }),
+
+  updateSesSettings: adminProcedure
+    .input(
+      z.object({
+        settingsId: z.string(),
+        sendRate: z.number(),
+        transactionalQuota: z.number(),
+      })
+    )
+    .mutation(async ({ input }) => {
+      return SesSettingsService.updateSesSetting({
+        id: input.settingsId,
+        sendingRateLimit: input.sendRate,
+        transactionalQuota: input.transactionalQuota,
       });
     }),
 

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

@@ -0,0 +1,183 @@
+import { Prisma } from "@prisma/client";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import {
+  teamProcedure,
+  createTRPCRouter,
+  campaignProcedure,
+  publicProcedure,
+} from "~/server/api/trpc";
+import {
+  sendCampaign,
+  subscribeContact,
+} from "~/server/service/campaign-service";
+import { validateDomainFromEmail } from "~/server/service/domain-service";
+
+export const campaignRouter = createTRPCRouter({
+  getCampaigns: teamProcedure
+    .input(
+      z.object({
+        page: z.number().optional(),
+      })
+    )
+    .query(async ({ ctx: { db, team }, input }) => {
+      const page = input.page || 1;
+      const limit = 30;
+      const offset = (page - 1) * limit;
+
+      const whereConditions: Prisma.CampaignFindManyArgs["where"] = {
+        teamId: team.id,
+      };
+
+      const countP = db.campaign.count({ where: whereConditions });
+
+      const campaignsP = db.campaign.findMany({
+        where: whereConditions,
+        select: {
+          id: true,
+          name: true,
+          from: true,
+          subject: true,
+          createdAt: true,
+          updatedAt: true,
+          status: true,
+        },
+        orderBy: {
+          createdAt: "desc",
+        },
+        skip: offset,
+        take: limit,
+      });
+
+      const [campaigns, count] = await Promise.all([campaignsP, countP]);
+
+      return { campaigns, totalPage: Math.ceil(count / limit) };
+    }),
+
+  createCampaign: teamProcedure
+    .input(
+      z.object({
+        name: z.string(),
+        from: z.string(),
+        subject: z.string(),
+      })
+    )
+    .mutation(async ({ ctx: { db, team }, input }) => {
+      const domain = await validateDomainFromEmail(input.from, team.id);
+
+      const campaign = await db.campaign.create({
+        data: {
+          ...input,
+          teamId: team.id,
+          domainId: domain.id,
+        },
+      });
+
+      return campaign;
+    }),
+
+  updateCampaign: campaignProcedure
+    .input(
+      z.object({
+        name: z.string().optional(),
+        from: z.string().optional(),
+        subject: z.string().optional(),
+        previewText: z.string().optional(),
+        content: z.string().optional(),
+        contactBookId: z.string().optional(),
+      })
+    )
+    .mutation(async ({ ctx: { db, team, campaign: campaignOld }, input }) => {
+      const { campaignId, ...data } = input;
+      if (data.contactBookId) {
+        const contactBook = await db.contactBook.findUnique({
+          where: { id: data.contactBookId },
+        });
+
+        if (!contactBook) {
+          throw new TRPCError({
+            code: "BAD_REQUEST",
+            message: "Contact book not found",
+          });
+        }
+      }
+      let domainId = campaignOld.domainId;
+      if (data.from) {
+        const domain = await validateDomainFromEmail(data.from, team.id);
+        domainId = domain.id;
+      }
+      const campaign = await db.campaign.update({
+        where: { id: campaignId },
+        data: {
+          ...data,
+          domainId,
+        },
+      });
+      return campaign;
+    }),
+
+  deleteCampaign: campaignProcedure.mutation(
+    async ({ ctx: { db, team }, input }) => {
+      const campaign = await db.campaign.delete({
+        where: { id: input.campaignId, teamId: team.id },
+      });
+      return campaign;
+    }
+  ),
+
+  getCampaign: campaignProcedure.query(async ({ ctx: { db, team }, input }) => {
+    const campaign = await db.campaign.findUnique({
+      where: { id: input.campaignId, teamId: team.id },
+    });
+
+    if (!campaign) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Campaign not found",
+      });
+    }
+
+    if (campaign?.contactBookId) {
+      const contactBook = await db.contactBook.findUnique({
+        where: { id: campaign.contactBookId },
+      });
+      return { ...campaign, contactBook };
+    }
+    return { ...campaign, contactBook: null };
+  }),
+
+  sendCampaign: campaignProcedure.mutation(
+    async ({ ctx: { db, team }, input }) => {
+      await sendCampaign(input.campaignId);
+    }
+  ),
+
+  reSubscribeContact: publicProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        hash: z.string(),
+      })
+    )
+    .mutation(async ({ ctx: { db }, input }) => {
+      await subscribeContact(input.id, input.hash);
+    }),
+
+  duplicateCampaign: campaignProcedure.mutation(
+    async ({ ctx: { db, team, campaign }, input }) => {
+      const newCampaign = await db.campaign.create({
+        data: {
+          name: `${campaign.name} (Copy)`,
+          from: campaign.from,
+          subject: campaign.subject,
+          content: campaign.content,
+          teamId: team.id,
+          domainId: campaign.domainId,
+          contactBookId: campaign.contactBookId,
+        },
+      });
+
+      return newCampaign;
+    }
+  ),
+});

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

@@ -0,0 +1,168 @@
+import { Prisma } from "@prisma/client";
+import { z } from "zod";
+
+import {
+  contactBookProcedure,
+  createTRPCRouter,
+  teamProcedure,
+} from "~/server/api/trpc";
+import * as contactService from "~/server/service/contact-service";
+
+export const contactsRouter = createTRPCRouter({
+  getContactBooks: teamProcedure.query(async ({ ctx: { db, team } }) => {
+    return db.contactBook.findMany({
+      where: {
+        teamId: team.id,
+      },
+      include: {
+        _count: {
+          select: { contacts: true },
+        },
+      },
+    });
+  }),
+
+  createContactBook: teamProcedure
+    .input(
+      z.object({
+        name: z.string(),
+      })
+    )
+    .mutation(async ({ ctx: { db, team }, input }) => {
+      const { name } = input;
+      const contactBook = await db.contactBook.create({
+        data: {
+          name,
+          teamId: team.id,
+          properties: {},
+        },
+      });
+
+      return contactBook;
+    }),
+
+  getContactBookDetails: contactBookProcedure.query(
+    async ({ ctx: { contactBook, db } }) => {
+      const [totalContacts, unsubscribedContacts] = await Promise.all([
+        db.contact.count({
+          where: { contactBookId: contactBook.id },
+        }),
+        db.contact.count({
+          where: { contactBookId: contactBook.id, subscribed: false },
+        }),
+      ]);
+
+      return {
+        ...contactBook,
+        totalContacts,
+        unsubscribedContacts,
+      };
+    }
+  ),
+
+  updateContactBook: contactBookProcedure
+    .input(
+      z.object({
+        contactBookId: z.string(),
+        name: z.string().optional(),
+        properties: z.record(z.string()).optional(),
+      })
+    )
+    .mutation(async ({ ctx: { db }, input }) => {
+      const { contactBookId, ...data } = input;
+      return db.contactBook.update({
+        where: { id: contactBookId },
+        data,
+      });
+    }),
+
+  deleteContactBook: contactBookProcedure
+    .input(z.object({ contactBookId: z.string() }))
+    .mutation(async ({ ctx: { db }, input }) => {
+      return db.contactBook.delete({ where: { id: input.contactBookId } });
+    }),
+
+  contacts: contactBookProcedure
+    .input(
+      z.object({
+        page: z.number().optional(),
+        subscribed: z.boolean().optional(),
+      })
+    )
+    .query(async ({ ctx: { db }, input }) => {
+      const page = input.page || 1;
+      const limit = 30;
+      const offset = (page - 1) * limit;
+
+      const whereConditions: Prisma.ContactFindManyArgs["where"] = {
+        contactBookId: input.contactBookId,
+        ...(input.subscribed !== undefined
+          ? { subscribed: input.subscribed }
+          : {}),
+      };
+
+      const countP = db.contact.count({ where: whereConditions });
+
+      const contactsP = db.contact.findMany({
+        where: whereConditions,
+        select: {
+          id: true,
+          email: true,
+          firstName: true,
+          lastName: true,
+          subscribed: true,
+          createdAt: true,
+          contactBookId: true,
+        },
+        orderBy: {
+          createdAt: "desc",
+        },
+        skip: offset,
+        take: limit,
+      });
+
+      const [contacts, count] = await Promise.all([contactsP, countP]);
+
+      return { contacts, totalPage: Math.ceil(count / limit) };
+    }),
+
+  addContacts: contactBookProcedure
+    .input(
+      z.object({
+        contacts: z.array(
+          z.object({
+            email: z.string(),
+            firstName: z.string().optional(),
+            lastName: z.string().optional(),
+            properties: z.record(z.string()).optional(),
+            subscribed: z.boolean().optional(),
+          })
+        ),
+      })
+    )
+    .mutation(async ({ ctx: { contactBook }, input }) => {
+      return contactService.bulkAddContacts(contactBook.id, input.contacts);
+    }),
+
+  updateContact: contactBookProcedure
+    .input(
+      z.object({
+        contactId: z.string(),
+        email: z.string().optional(),
+        firstName: z.string().optional(),
+        lastName: z.string().optional(),
+        properties: z.record(z.string()).optional(),
+        subscribed: z.boolean().optional(),
+      })
+    )
+    .mutation(async ({ input }) => {
+      const { contactId, ...contact } = input;
+      return contactService.updateContact(contactId, contact);
+    }),
+
+  deleteContact: contactBookProcedure
+    .input(z.object({ contactId: z.string() }))
+    .mutation(async ({ input }) => {
+      return contactService.deleteContact(input.contactId);
+    }),
+});

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

@@ -175,7 +175,7 @@ export const emailRouter = createTRPCRouter({
         select: {
           emailEvents: {
             orderBy: {
-              createdAt: "asc",
+              status: "asc",
             },
           },
           id: true,

apps/web/src/server/api/trpc.ts

@@ -9,7 +9,7 @@
 
 import { initTRPC, TRPCError } from "@trpc/server";
 import superjson from "superjson";
-import { ZodError } from "zod";
+import { z, ZodError } from "zod";
 import { env } from "~/env";
 
 import { getServerAuthSession } from "~/server/auth";
@@ -125,6 +125,60 @@ export const teamProcedure = protectedProcedure.use(async ({ ctx, next }) => {
   });
 });
 
+export const contactBookProcedure = teamProcedure
+  .input(
+    z.object({
+      contactBookId: z.string(),
+    })
+  )
+  .use(async ({ ctx, next, input }) => {
+    const contactBook = await db.contactBook.findUnique({
+      where: { id: input.contactBookId },
+    });
+    if (!contactBook) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Contact book not found",
+      });
+    }
+
+    if (contactBook.teamId !== ctx.team.id) {
+      throw new TRPCError({
+        code: "UNAUTHORIZED",
+        message: "You are not authorized to access this contact book",
+      });
+    }
+
+    return next({ ctx: { ...ctx, contactBook } });
+  });
+
+export const campaignProcedure = teamProcedure
+  .input(
+    z.object({
+      campaignId: z.string(),
+    })
+  )
+  .use(async ({ ctx, next, input }) => {
+    const campaign = await db.campaign.findUnique({
+      where: { id: input.campaignId },
+    });
+    if (!campaign) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Campaign not found",
+      });
+    }
+
+    if (campaign.teamId !== ctx.team.id) {
+      throw new TRPCError({
+        code: "UNAUTHORIZED",
+        message: "You are not authorized to access this campaign",
+      });
+    }
+
+    return next({ ctx: { ...ctx, campaign } });
+  });
+
 /**
  * To manage application settings, for hosted version, authenticated users will be considered as admin
  */

apps/web/src/server/aws/ses.ts

@@ -112,6 +112,7 @@ export async function sendEmailThroughSes({
   replyTo,
   region,
   configurationSetName,
+  unsubUrl,
 }: Partial<EmailContent> & {
   region: string;
   configurationSetName: string;
@@ -149,6 +150,14 @@ export async function sendEmailThroughSes({
             Charset: "UTF-8",
           },
         },
+        ...(unsubUrl
+          ? {
+              Headers: [
+                { Name: "List-Unsubscribe", Value: `<${unsubUrl}>` },
+                { Name: "List-Unsubscribe-Post", Value: "One-Click" },
+              ],
+            }
+          : {}),
       },
     },
     ConfigurationSetName: configurationSetName,

apps/web/src/server/public-api/api-utils.ts

@@ -0,0 +1,27 @@
+import { Context } from "hono";
+import { db } from "../db";
+import { UnsendApiError } from "./api-error";
+
+export const getContactBook = async (c: Context, teamId: number) => {
+  const contactBookId = c.req.param("contactBookId");
+
+  if (!contactBookId) {
+    throw new UnsendApiError({
+      code: "BAD_REQUEST",
+      message: "contactBookId is mandatory",
+    });
+  }
+
+  const contactBook = await db.contactBook.findUnique({
+    where: { id: contactBookId, teamId },
+  });
+
+  if (!contactBook) {
+    throw new UnsendApiError({
+      code: "NOT_FOUND",
+      message: "Contact book not found for this team",
+    });
+  }
+
+  return contactBook;
+};

apps/web/src/server/public-api/api/contacts/add-contact.ts

@@ -0,0 +1,65 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { PublicAPIApp } from "~/server/public-api/hono";
+import { getTeamFromToken } from "~/server/public-api/auth";
+import { addOrUpdateContact } from "~/server/service/contact-service";
+import { getContactBook } from "../../api-utils";
+
+const route = createRoute({
+  method: "post",
+  path: "/v1/contactBooks/{contactBookId}/contacts",
+  request: {
+    params: z.object({
+      contactBookId: z
+        .string()
+        .min(3)
+        .openapi({
+          param: {
+            name: "contactBookId",
+            in: "path",
+          },
+          example: "cuiwqdj74rygf74",
+        }),
+    }),
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            email: z.string(),
+            firstName: z.string().optional(),
+            lastName: z.string().optional(),
+            properties: z.record(z.string()).optional(),
+            subscribed: z.boolean().optional(),
+          }),
+        },
+      },
+    },
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z.object({ contactId: z.string().optional() }),
+        },
+      },
+      description: "Retrieve the user",
+    },
+  },
+});
+
+function addContact(app: PublicAPIApp) {
+  app.openapi(route, async (c) => {
+    const team = await getTeamFromToken(c);
+
+    const contactBook = await getContactBook(c, team.id);
+
+    const contact = await addOrUpdateContact(
+      contactBook.id,
+      c.req.valid("json")
+    );
+
+    return c.json({ contactId: contact.id });
+  });
+}
+
+export default addContact;

apps/web/src/server/public-api/api/contacts/get-contact.ts

@@ -0,0 +1,82 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { PublicAPIApp } from "~/server/public-api/hono";
+import { getTeamFromToken } from "~/server/public-api/auth";
+import { db } from "~/server/db";
+import { UnsendApiError } from "../../api-error";
+import { getContactBook } from "../../api-utils";
+
+const route = createRoute({
+  method: "get",
+  path: "/v1/contactBooks/{contactBookId}/contacts/{contactId}",
+  request: {
+    params: z.object({
+      contactBookId: z.string().openapi({
+        param: {
+          name: "contactBookId",
+          in: "path",
+        },
+        example: "cuiwqdj74rygf74",
+      }),
+      contactId: z.string().openapi({
+        param: {
+          name: "contactId",
+          in: "path",
+        },
+        example: "cuiwqdj74rygf74",
+      }),
+    }),
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            id: z.string(),
+            firstName: z.string().optional().nullable(),
+            lastName: z.string().optional().nullable(),
+            email: z.string(),
+            subscribed: z.boolean().default(true),
+            properties: z.record(z.string()),
+            contactBookId: z.string(),
+            createdAt: z.string(),
+            updatedAt: z.string(),
+          }),
+        },
+      },
+      description: "Retrieve the contact",
+    },
+  },
+});
+
+function getContact(app: PublicAPIApp) {
+  app.openapi(route, async (c) => {
+    const team = await getTeamFromToken(c);
+
+    await getContactBook(c, team.id);
+
+    const contactId = c.req.param("contactId");
+
+    const contact = await db.contact.findUnique({
+      where: {
+        id: contactId,
+      },
+    });
+
+    if (!contact) {
+      throw new UnsendApiError({
+        code: "NOT_FOUND",
+        message: "Contact not found",
+      });
+    }
+
+    // Ensure properties is a Record<string, string>
+    const sanitizedContact = {
+      ...contact,
+      properties: contact.properties as Record<string, string>,
+    };
+
+    return c.json(sanitizedContact);
+  });
+}
+
+export default getContact;

apps/web/src/server/public-api/api/contacts/update-contact.ts

@@ -0,0 +1,66 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { PublicAPIApp } from "~/server/public-api/hono";
+import { getTeamFromToken } from "~/server/public-api/auth";
+import { updateContact } from "~/server/service/contact-service";
+import { getContactBook } from "../../api-utils";
+
+const route = createRoute({
+  method: "patch",
+  path: "/v1/contactBooks/{contactBookId}/contacts/{contactId}",
+  request: {
+    params: z.object({
+      contactBookId: z.string().openapi({
+        param: {
+          name: "contactBookId",
+          in: "path",
+        },
+        example: "cuiwqdj74rygf74",
+      }),
+      contactId: z.string().openapi({
+        param: {
+          name: "contactId",
+          in: "path",
+        },
+        example: "cuiwqdj74rygf74",
+      }),
+    }),
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            firstName: z.string().optional(),
+            lastName: z.string().optional(),
+            properties: z.record(z.string()).optional(),
+            subscribed: z.boolean().optional(),
+          }),
+        },
+      },
+    },
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z.object({ contactId: z.string().optional() }),
+        },
+      },
+      description: "Retrieve the user",
+    },
+  },
+});
+
+function updateContactInfo(app: PublicAPIApp) {
+  app.openapi(route, async (c) => {
+    const team = await getTeamFromToken(c);
+
+    await getContactBook(c, team.id);
+    const contactId = c.req.param("contactId");
+
+    const contact = await updateContact(contactId, c.req.valid("json"));
+
+    return c.json({ contactId: contact.id });
+  });
+}
+
+export default updateContactInfo;

apps/web/src/server/public-api/api/emails/get-email.ts

@@ -50,7 +50,7 @@ const route = createRoute({
           }),
         },
       },
-      description: "Retrieve the user",
+      description: "Retrieve the email",
     },
   },
 });

apps/web/src/server/public-api/index.ts

@@ -2,6 +2,9 @@ import { getApp } from "./hono";
 import getDomains from "./api/domains/get-domains";
 import sendEmail from "./api/emails/send-email";
 import getEmail from "./api/emails/get-email";
+import addContact from "./api/contacts/add-contact";
+import updateContactInfo from "./api/contacts/update-contact";
+import getContact from "./api/contacts/get-contact";
 
 export const app = getApp();
 
@@ -12,4 +15,9 @@ getDomains(app);
 getEmail(app);
 sendEmail(app);
 
+/**Contact related APIs */
+addContact(app);
+updateContactInfo(app);
+getContact(app);
+
 export default app;

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

@@ -0,0 +1,309 @@
+import { EmailRenderer } from "@unsend/email-editor/src/renderer";
+import { db } from "../db";
+import { createHash } from "crypto";
+import { env } from "~/env";
+import { Campaign, Contact, EmailStatus } from "@prisma/client";
+import { validateDomainFromEmail } from "./domain-service";
+import { EmailQueueService } from "./email-queue-service";
+
+export async function sendCampaign(id: string) {
+  let campaign = await db.campaign.findUnique({
+    where: { id },
+  });
+
+  if (!campaign) {
+    throw new Error("Campaign not found");
+  }
+
+  if (!campaign.content) {
+    throw new Error("No content added for campaign");
+  }
+
+  let jsonContent: Record<string, any>;
+
+  try {
+    jsonContent = JSON.parse(campaign.content);
+    const renderer = new EmailRenderer(jsonContent);
+    const html = await renderer.render();
+    campaign = await db.campaign.update({
+      where: { id },
+      data: { html },
+    });
+  } catch (error) {
+    console.error(error);
+    throw new Error("Failed to parse campaign content");
+  }
+
+  if (!campaign.contactBookId) {
+    throw new Error("No contact book found for campaign");
+  }
+
+  const contactBook = await db.contactBook.findUnique({
+    where: { id: campaign.contactBookId },
+    include: {
+      contacts: {
+        where: {
+          subscribed: true,
+        },
+      },
+    },
+  });
+
+  if (!contactBook) {
+    throw new Error("Contact book not found");
+  }
+
+  if (!campaign.html) {
+    throw new Error("No HTML content for campaign");
+  }
+
+  await sendCampaignEmail(campaign, {
+    campaignId: campaign.id,
+    from: campaign.from,
+    subject: campaign.subject,
+    html: campaign.html,
+    replyTo: campaign.replyTo,
+    cc: campaign.cc,
+    bcc: campaign.bcc,
+    teamId: campaign.teamId,
+    contacts: contactBook.contacts,
+  });
+
+  await db.campaign.update({
+    where: { id },
+    data: { status: "SENT", total: contactBook.contacts.length },
+  });
+}
+
+export function createUnsubUrl(contactId: string, campaignId: string) {
+  const unsubId = `${contactId}-${campaignId}`;
+
+  const unsubHash = createHash("sha256")
+    .update(`${unsubId}-${env.NEXTAUTH_SECRET}`)
+    .digest("hex");
+
+  return `${env.NEXTAUTH_URL}/unsubscribe?id=${unsubId}&hash=${unsubHash}`;
+}
+
+export async function unsubscribeContact(id: string, hash: string) {
+  const [contactId, campaignId] = id.split("-");
+
+  if (!contactId || !campaignId) {
+    throw new Error("Invalid unsubscribe link");
+  }
+
+  // Verify the hash
+  const expectedHash = createHash("sha256")
+    .update(`${id}-${env.NEXTAUTH_SECRET}`)
+    .digest("hex");
+
+  if (hash !== expectedHash) {
+    throw new Error("Invalid unsubscribe link");
+  }
+
+  // Update the contact's subscription status
+  try {
+    const contact = await db.contact.findUnique({
+      where: { id: contactId },
+    });
+
+    if (!contact) {
+      throw new Error("Contact not found");
+    }
+
+    if (contact.subscribed) {
+      await db.contact.update({
+        where: { id: contactId },
+        data: { subscribed: false },
+      });
+
+      await db.campaign.update({
+        where: { id: campaignId },
+        data: {
+          unsubscribed: {
+            increment: 1,
+          },
+        },
+      });
+    }
+
+    return contact;
+  } catch (error) {
+    console.error("Error unsubscribing contact:", error);
+    throw new Error("Failed to unsubscribe contact");
+  }
+}
+
+export async function subscribeContact(id: string, hash: string) {
+  const [contactId, campaignId] = id.split("-");
+
+  if (!contactId || !campaignId) {
+    throw new Error("Invalid subscribe link");
+  }
+
+  // Verify the hash
+  const expectedHash = createHash("sha256")
+    .update(`${id}-${env.NEXTAUTH_SECRET}`)
+    .digest("hex");
+
+  if (hash !== expectedHash) {
+    throw new Error("Invalid subscribe link");
+  }
+
+  // Update the contact's subscription status
+  try {
+    const contact = await db.contact.findUnique({
+      where: { id: contactId },
+    });
+
+    if (!contact) {
+      throw new Error("Contact not found");
+    }
+
+    if (!contact.subscribed) {
+      await db.contact.update({
+        where: { id: contactId },
+        data: { subscribed: true },
+      });
+
+      await db.campaign.update({
+        where: { id: campaignId },
+        data: {
+          unsubscribed: {
+            decrement: 1,
+          },
+        },
+      });
+    }
+
+    return true;
+  } catch (error) {
+    console.error("Error subscribing contact:", error);
+    throw new Error("Failed to subscribe contact");
+  }
+}
+
+type CampainEmail = {
+  campaignId: string;
+  from: string;
+  subject: string;
+  html: string;
+  replyTo?: string[];
+  cc?: string[];
+  bcc?: string[];
+  teamId: number;
+  contacts: Array<Contact>;
+};
+
+export async function sendCampaignEmail(
+  campaign: Campaign,
+  emailData: CampainEmail
+) {
+  const { campaignId, from, subject, replyTo, cc, bcc, teamId, contacts } =
+    emailData;
+
+  const jsonContent = JSON.parse(campaign.content || "{}");
+  const renderer = new EmailRenderer(jsonContent);
+
+  const domain = await validateDomainFromEmail(from, teamId);
+
+  const contactWithHtml = await Promise.all(
+    contacts.map(async (contact) => {
+      const unsubscribeUrl = createUnsubUrl(contact.id, campaignId);
+
+      return {
+        ...contact,
+        html: await renderer.render({
+          shouldReplaceVariableValues: true,
+          variableValues: {
+            email: contact.email,
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+          },
+          linkValues: {
+            "{{unsend_unsubscribe_url}}": unsubscribeUrl,
+          },
+        }),
+      };
+    })
+  );
+
+  // Create emails in bulk
+  await db.email.createMany({
+    data: contactWithHtml.map((contact) => ({
+      to: [contact.email],
+      replyTo: replyTo
+        ? Array.isArray(replyTo)
+          ? replyTo
+          : [replyTo]
+        : undefined,
+      cc: cc ? (Array.isArray(cc) ? cc : [cc]) : undefined,
+      bcc: bcc ? (Array.isArray(bcc) ? bcc : [bcc]) : undefined,
+      from,
+      subject,
+      html: contact.html,
+      teamId,
+      campaignId,
+      contactId: contact.id,
+      domainId: domain.id,
+    })),
+  });
+
+  // Fetch created emails
+  const emails = await db.email.findMany({
+    where: {
+      teamId,
+      campaignId,
+    },
+  });
+
+  // Queue emails
+  await Promise.all(
+    emails.map((email) =>
+      EmailQueueService.queueEmail(email.id, domain.region, false)
+    )
+  );
+}
+
+export async function updateCampaignAnalytics(
+  campaignId: string,
+  emailStatus: EmailStatus
+) {
+  const campaign = await db.campaign.findUnique({
+    where: { id: campaignId },
+  });
+
+  if (!campaign) {
+    throw new Error("Campaign not found");
+  }
+
+  const updateData: Record<string, any> = {};
+
+  switch (emailStatus) {
+    case EmailStatus.SENT:
+      updateData.sent = { increment: 1 };
+      break;
+    case EmailStatus.DELIVERED:
+      updateData.delivered = { increment: 1 };
+      break;
+    case EmailStatus.OPENED:
+      updateData.opened = { increment: 1 };
+      break;
+    case EmailStatus.CLICKED:
+      updateData.clicked = { increment: 1 };
+      break;
+    case EmailStatus.BOUNCED:
+      updateData.bounced = { increment: 1 };
+      break;
+    case EmailStatus.COMPLAINED:
+      updateData.complained = { increment: 1 };
+      break;
+    default:
+      break;
+  }
+
+  await db.campaign.update({
+    where: { id: campaignId },
+    data: updateData,
+  });
+}

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

@@ -0,0 +1,92 @@
+import { db } from "../db";
+
+export type ContactInput = {
+  email: string;
+  firstName?: string;
+  lastName?: string;
+  properties?: Record<string, string>;
+  subscribed?: boolean;
+};
+
+export async function addOrUpdateContact(
+  contactBookId: string,
+  contact: ContactInput
+) {
+  const createdContact = await db.contact.upsert({
+    where: {
+      contactBookId_email: {
+        contactBookId,
+        email: contact.email,
+      },
+    },
+    create: {
+      contactBookId,
+      email: contact.email,
+      firstName: contact.firstName,
+      lastName: contact.lastName,
+      properties: contact.properties ?? {},
+      subscribed: contact.subscribed,
+    },
+    update: {
+      firstName: contact.firstName,
+      lastName: contact.lastName,
+      properties: contact.properties ?? {},
+      subscribed: contact.subscribed,
+    },
+  });
+
+  return createdContact;
+}
+
+export async function updateContact(
+  contactId: string,
+  contact: Partial<ContactInput>
+) {
+  return db.contact.update({
+    where: {
+      id: contactId,
+    },
+    data: contact,
+  });
+}
+
+export async function deleteContact(contactId: string) {
+  return db.contact.delete({
+    where: {
+      id: contactId,
+    },
+  });
+}
+
+export async function bulkAddContacts(
+  contactBookId: string,
+  contacts: Array<ContactInput>
+) {
+  const createdContacts = await Promise.all(
+    contacts.map((contact) => addOrUpdateContact(contactBookId, contact))
+  );
+
+  return createdContacts;
+}
+
+export async function unsubscribeContact(contactId: string) {
+  await db.contact.update({
+    where: {
+      id: contactId,
+    },
+    data: {
+      subscribed: false,
+    },
+  });
+}
+
+export async function subscribeContact(contactId: string) {
+  await db.contact.update({
+    where: {
+      id: contactId,
+    },
+    data: {
+      subscribed: true,
+    },
+  });
+}

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

@@ -4,9 +4,45 @@ import * as tldts from "tldts";
 import * as ses from "~/server/aws/ses";
 import { db } from "~/server/db";
 import { SesSettingsService } from "./ses-settings-service";
+import { UnsendApiError } from "../public-api/api-error";
 
 const dnsResolveTxt = util.promisify(dns.resolveTxt);
 
+export async function validateDomainFromEmail(email: string, teamId: number) {
+  let fromDomain = email.split("@")[1];
+  if (fromDomain?.endsWith(">")) {
+    fromDomain = fromDomain.slice(0, -1);
+  }
+
+  if (!fromDomain) {
+    throw new UnsendApiError({
+      code: "BAD_REQUEST",
+      message: "From email is invalid",
+    });
+  }
+
+  const domain = await db.domain.findUnique({
+    where: { name: fromDomain, teamId },
+  });
+
+  if (!domain) {
+    throw new UnsendApiError({
+      code: "BAD_REQUEST",
+      message:
+        "Domain of from email is wrong. Use the domain verified by unsend",
+    });
+  }
+
+  if (domain.status !== "SUCCESS") {
+    throw new UnsendApiError({
+      code: "BAD_REQUEST",
+      message: "Domain is not verified",
+    });
+  }
+
+  return domain;
+}
+
 export async function createDomain(
   teamId: number,
   name: string,

apps/web/src/server/service/email-queue-service.ts

@@ -5,54 +5,120 @@ import { getConfigurationSetName } from "~/utils/ses-utils";
 import { db } from "../db";
 import { sendEmailThroughSes, sendEmailWithAttachments } from "../aws/ses";
 import { getRedis } from "../redis";
+import { createUnsubUrl } from "./campaign-service";
+
+function createQueueAndWorker(region: string, quota: number, suffix: string) {
+  const connection = getRedis();
+
+  const queueName = `${region}-${suffix}`;
+
+  const queue = new Queue(queueName, { connection });
+
+  const worker = new Worker(queueName, executeEmail, {
+    concurrency: quota,
+    connection,
+  });
+
+  return { queue, worker };
+}
 
 export class EmailQueueService {
   private static initialized = false;
-  private static regionQueue = new Map<string, Queue>();
-  private static regionWorker = new Map<string, Worker>();
+  public static transactionalQueue = new Map<string, Queue>();
+  private static transactionalWorker = new Map<string, Worker>();
+  public static marketingQueue = new Map<string, Queue>();
+  private static marketingWorker = new Map<string, Worker>();
 
-  public static initializeQueue(region: string, quota: number) {
-    const connection = getRedis();
+  public static initializeQueue(
+    region: string,
+    quota: number,
+    transactionalQuotaPercentage: number
+  ) {
     console.log(`[EmailQueueService]: Initializing queue for region ${region}`);
 
-    const queueName = `${region}-transaction`;
+    const transactionalQuota = Math.floor(
+      (quota * transactionalQuotaPercentage) / 100
+    );
+    const marketingQuota = quota - transactionalQuota;
 
-    const queue = new Queue(queueName, { connection });
+    console.log(
+      "is transactional queue",
+      this.transactionalQueue.has(region),
+      "is marketing queue",
+      this.marketingQueue.has(region)
+    );
 
-    const worker = new Worker(queueName, executeEmail, {
-      limiter: {
-        max: quota,
-        duration: 1000,
-      },
-      concurrency: quota,
-      connection,
-    });
+    if (this.transactionalQueue.has(region)) {
+      console.log(
+        `[EmailQueueService]: Updating transactional quota for region ${region} to ${transactionalQuota}`
+      );
+      const transactionalWorker = this.transactionalWorker.get(region);
+      if (transactionalWorker) {
+        transactionalWorker.concurrency = transactionalQuota;
+      }
+    } else {
+      console.log(
+        `[EmailQueueService]: Creating transactional queue for region ${region} with quota ${transactionalQuota}`
+      );
+      const { queue: transactionalQueue, worker: transactionalWorker } =
+        createQueueAndWorker(region, transactionalQuota ?? 1, "transaction");
+      this.transactionalQueue.set(region, transactionalQueue);
+      this.transactionalWorker.set(region, transactionalWorker);
+    }
 
-    this.regionQueue.set(region, queue);
-    this.regionWorker.set(region, worker);
+    if (this.marketingQueue.has(region)) {
+      console.log(
+        `[EmailQueueService]: Updating marketing quota for region ${region} to ${marketingQuota}`
+      );
+      const marketingWorker = this.marketingWorker.get(region);
+      if (marketingWorker) {
+        marketingWorker.concurrency = marketingQuota;
+      }
+    } else {
+      console.log(
+        `[EmailQueueService]: Creating marketing queue for region ${region} with quota ${marketingQuota}`
+      );
+      const { queue: marketingQueue, worker: marketingWorker } =
+        createQueueAndWorker(region, marketingQuota ?? 1, "marketing");
+      this.marketingQueue.set(region, marketingQueue);
+      this.marketingWorker.set(region, marketingWorker);
+    }
   }
 
-  public static async queueEmail(emailId: string, region: string) {
+  public static async queueEmail(
+    emailId: string,
+    region: string,
+    transactional: boolean,
+    unsubUrl?: string
+  ) {
     if (!this.initialized) {
       await this.init();
     }
-    const queue = this.regionQueue.get(region);
+    const queue = transactional
+      ? this.transactionalQueue.get(region)
+      : this.marketingQueue.get(region);
     if (!queue) {
       throw new Error(`Queue for region ${region} not found`);
     }
-    queue.add("send-email", { emailId, timestamp: Date.now() });
+    queue.add("send-email", { emailId, timestamp: Date.now(), unsubUrl });
   }
 
   public static async init() {
     const sesSettings = await db.sesSetting.findMany();
     for (const sesSetting of sesSettings) {
-      this.initializeQueue(sesSetting.region, sesSetting.sesEmailRateLimit);
+      this.initializeQueue(
+        sesSetting.region,
+        sesSetting.sesEmailRateLimit,
+        sesSetting.transactionalQuota
+      );
     }
     this.initialized = true;
   }
 }
 
-async function executeEmail(job: Job<{ emailId: string; timestamp: number }>) {
+async function executeEmail(
+  job: Job<{ emailId: string; timestamp: number; unsubUrl?: string }>
+) {
   console.log(
     `[EmailQueueService]: Executing email job ${job.data.emailId}, time elapsed: ${Date.now() - job.data.timestamp}ms`
   );
@@ -88,13 +154,15 @@ async function executeEmail(job: Job<{ emailId: string; timestamp: number }>) {
   }
 
   console.log(`[EmailQueueService]: Sending email ${email.id}`);
+  const unsubUrl = job.data.unsubUrl;
+
   try {
     const messageId = attachments.length
       ? await sendEmailWithAttachments({
           to: email.to,
           from: email.from,
           subject: email.subject,
-          text: email.text ?? undefined,
+          text: email.text ?? "",
           html: email.html ?? undefined,
           region: domain?.region ?? env.AWS_DEFAULT_REGION,
           configurationSetName,
@@ -105,11 +173,12 @@ async function executeEmail(job: Job<{ emailId: string; timestamp: number }>) {
           from: email.from,
           subject: email.subject,
           replyTo: email.replyTo ?? undefined,
-          text: email.text ?? undefined,
+          text: email.text ?? "",
           html: email.html ?? undefined,
           region: domain?.region ?? env.AWS_DEFAULT_REGION,
           configurationSetName,
           attachments,
+          unsubUrl,
         });
 
     // Delete attachments after sending the email

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

@@ -2,7 +2,14 @@ import { EmailContent } from "~/types";
 import { db } from "../db";
 import { UnsendApiError } from "~/server/public-api/api-error";
 import { EmailQueueService } from "./email-queue-service";
+import { validateDomainFromEmail } from "./domain-service";
+import { Campaign, Contact } from "@prisma/client";
+import { EmailRenderer } from "@unsend/email-editor/src/renderer";
+import { createUnsubUrl } from "./campaign-service";
 
+/**
+ Send transactional email
+ */
 export async function sendEmail(
   emailContent: EmailContent & { teamId: number }
 ) {
@@ -19,29 +26,7 @@ export async function sendEmail(
     bcc,
   } = emailContent;
 
-  let fromDomain = from.split("@")[1];
-  if (fromDomain?.endsWith(">")) {
-    fromDomain = fromDomain.slice(0, -1);
-  }
-
-  const domain = await db.domain.findFirst({
-    where: { teamId, name: fromDomain },
-  });
-
-  if (!domain) {
-    throw new UnsendApiError({
-      code: "BAD_REQUEST",
-      message:
-        "Domain of from email is wrong. Use the email verified by unsend",
-    });
-  }
-
-  if (domain.status !== "SUCCESS") {
-    throw new UnsendApiError({
-      code: "BAD_REQUEST",
-      message: "Domain is not verified",
-    });
-  }
+  const domain = await validateDomainFromEmail(from, teamId);
 
   const email = await db.email.create({
     data: {
@@ -64,7 +49,7 @@ export async function sendEmail(
   });
 
   try {
-    await EmailQueueService.queueEmail(email.id, domain.region);
+    await EmailQueueService.queueEmail(email.id, domain.region, true);
   } catch (error: any) {
     await db.emailEvent.create({
       data: {

apps/web/src/server/service/ses-hook-parser.ts

@@ -1,8 +1,8 @@
-import { EmailStatus } from "@prisma/client";
-import { SesEvent, SesEventDataKey } from "~/types/aws-types";
+import { EmailStatus, Prisma } from "@prisma/client";
+import { SesClick, SesEvent, SesEventDataKey } from "~/types/aws-types";
 import { db } from "../db";
-
-const STATUS_LIST = Object.values(EmailStatus);
+import { updateCampaignAnalytics } from "./campaign-service";
+import { env } from "~/env";
 
 export async function parseSesHook(data: SesEvent) {
   const mailStatus = getEmailStatus(data);
@@ -34,14 +34,34 @@ export async function parseSesHook(data: SesEvent) {
     return true;
   }
 
-  await db.email.update({
-    where: {
-      id: email.id,
-    },
-    data: {
-      latestStatus: getLatestStatus(email.latestStatus, mailStatus),
-    },
-  });
+  // Update the latest status and to avoid race conditions
+  await db.$executeRaw`
+      UPDATE "Email"
+      SET "latestStatus" = CASE
+        WHEN ${mailStatus}::text::\"EmailStatus\" > "latestStatus" OR "latestStatus" IS NULL 
+        THEN ${mailStatus}::text::\"EmailStatus\"
+        ELSE "latestStatus"
+      END
+      WHERE id = ${email.id}
+    `;
+
+  if (email.campaignId) {
+    if (
+      mailStatus !== "CLICKED" ||
+      !(mailData as SesClick).link.startsWith(`${env.NEXTAUTH_URL}/unsubscribe`)
+    ) {
+      const mailEvent = await db.emailEvent.findFirst({
+        where: {
+          emailId: email.id,
+          status: mailStatus,
+        },
+      });
+
+      if (!mailEvent) {
+        await updateCampaignAnalytics(email.campaignId, mailStatus);
+      }
+    }
+  }
 
   await db.emailEvent.create({
     data: {
@@ -89,12 +109,3 @@ function getEmailData(data: SesEvent) {
     return data[eventType.toLowerCase() as SesEventDataKey];
   }
 }
-
-function getLatestStatus(
-  currentEmailStatus: EmailStatus,
-  incomingStatus: EmailStatus
-) {
-  const index = STATUS_LIST.indexOf(currentEmailStatus);
-  const incomingIndex = STATUS_LIST.indexOf(incomingStatus);
-  return STATUS_LIST[Math.max(index, incomingIndex)] ?? incomingStatus;
-}

apps/web/src/server/service/ses-settings-service.ts

@@ -52,9 +52,13 @@ export class SesSettingsService {
   public static async createSesSetting({
     region,
     unsendUrl,
+    sendingRateLimit,
+    transactionalQuota,
   }: {
     region: string;
     unsendUrl: string;
+    sendingRateLimit: number;
+    transactionalQuota: number;
   }) {
     await this.checkInitialized();
     if (this.cache[region]) {
@@ -80,12 +84,62 @@ export class SesSettingsService {
         region,
         callbackUrl: `${parsedUrl}/api/ses_callback`,
         topic: `${idPrefix}-${region}-unsend`,
+        sesEmailRateLimit: sendingRateLimit,
+        transactionalQuota,
         idPrefix,
       },
     });
 
     await createSettingInAws(setting);
-    EmailQueueService.initializeQueue(region, setting.sesEmailRateLimit);
+
+    EmailQueueService.initializeQueue(
+      region,
+      setting.sesEmailRateLimit,
+      setting.transactionalQuota
+    );
+    console.log(
+      EmailQueueService.transactionalQueue,
+      EmailQueueService.marketingQueue
+    );
+
+    await this.invalidateCache();
+  }
+
+  public static async updateSesSetting({
+    id,
+    sendingRateLimit,
+    transactionalQuota,
+  }: {
+    id: string;
+    sendingRateLimit: number;
+    transactionalQuota: number;
+  }) {
+    await this.checkInitialized();
+
+    const setting = await db.sesSetting.update({
+      where: {
+        id,
+      },
+      data: {
+        transactionalQuota,
+        sesEmailRateLimit: sendingRateLimit,
+      },
+    });
+    console.log(
+      EmailQueueService.transactionalQueue,
+      EmailQueueService.marketingQueue
+    );
+
+    EmailQueueService.initializeQueue(
+      setting.region,
+      setting.sesEmailRateLimit,
+      setting.transactionalQuota
+    );
+
+    console.log(
+      EmailQueueService.transactionalQueue,
+      EmailQueueService.marketingQueue
+    );
 
     await this.invalidateCache();
   }