dubinc · steven-tey · Sep 15, 2025 · Aug 27, 2025 · Aug 27, 2025 · Aug 28, 2025
diff --git a/apps/web/app/(ee)/api/cron/messages/notify-partner/route.ts b/apps/web/app/(ee)/api/cron/messages/notify-partner/route.ts
@@ -0,0 +1,166 @@
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
+import { resend } from "@dub/email/resend";
+import { VARIANT_TO_FROM_MAP } from "@dub/email/resend/constants";
+import NewMessageFromProgram from "@dub/email/templates/new-message-from-program";
+import { prisma } from "@dub/prisma";
+import { NotificationEmailType } from "@dub/prisma/client";
+import { log } from "@dub/utils";
+import { subDays } from "date-fns";
+import { z } from "zod";
+import { logAndRespond } from "../../utils";
+
+export const dynamic = "force-dynamic";
+
+const schema = z.object({
+  programId: z.string(),
+  partnerId: z.string(),
+  lastMessageId: z.string(),
+});
+
+// POST /api/cron/messages/notify-partner
+// Notify a partner about unread messages from a program
+export async function POST(req: Request) {
+  try {
+    const rawBody = await req.text();
+
+    await verifyQstashSignature({
+      req,
+      rawBody,
+    });
+
+    const { programId, partnerId, lastMessageId } = schema.parse(
+      JSON.parse(rawBody),
+    );
+
+    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
+      where: {
+        partnerId_programId: {
+          partnerId,
+          programId,
+        },
+        status: "approved",
+      },
+      include: {
-    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
-      where: {
-        partnerId_programId: {
-          partnerId,
-          programId,
-        },
-        status: "approved",
-      },
-      include: {
+    const programEnrollment = await prisma.programEnrollment.findFirstOrThrow({
+      where: {
+        partnerId,
+        programId,
+        status: "approved",
+      },
+      include: {
+        program: true,
+        partner: {
+          /* existing partner include fields */
+        },
+      },
+    });
-    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
-      where: {
-        partnerId_programId: {
-          partnerId,
-          programId,
-        },
-        status: "approved",
-      },
-      include: {
+    const programEnrollment = await prisma.programEnrollment.findFirstOrThrow({
+      where: {
+        partnerId,
+        programId,
+        status: "approved",
+      },
+      include: {
+        program: true,
+        partner: {
+          /* existing partner include fields */
+        },
+      },
+    });
+        program: true,
+        partner: {
+          include: {
+            messages: {
+              where: {
+                programId,
+                senderPartnerId: null, // Not sent by the partner
+                createdAt: {
+                  gt: subDays(new Date(), 3), // Sent in the last 3 days
+                },
+                readInApp: null, // Unread
+                readInEmail: null, // Unread
+                emails: {
+                  none: {}, // No emails sent yet
+                },
+              },
+              include: {
+                senderUser: true,
+              },
+            },
+            users: {
+              include: {
+                user: true,
+              },
+              where: {
+                notificationPreferences: {
+                  newMessageFromProgram: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const unreadMessages = programEnrollment.partner.messages.sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+    );
+
+    if (unreadMessages.length === 0)
+      return logAndRespond(
+        `No unread messages found for partner ${partnerId} in program ${programId}. Skipping...`,
+      );
+
+    if (unreadMessages[unreadMessages.length - 1].id !== lastMessageId)
+      return logAndRespond(
+        `There is a more recent unread message than ${lastMessageId}. Skipping...`,
+      );
+
+    const partnerEmailsToNotify = programEnrollment.partner.users
+      .map(({ user }) => user.email)
+      .filter(Boolean) as string[];
+
+    if (partnerEmailsToNotify.length === 0)
+      return logAndRespond(
+        `No partner emails to notify for partner ${partnerId}. Skipping...`,
+      );
+
+    const program = programEnrollment.program;
+
+    const { data, error } = await resend.batch.send(
+      partnerEmailsToNotify.map((email) => ({
+        subject: `${program.name} sent ${unreadMessages.length === 1 ? "a message" : `${unreadMessages.length} messages`}`,
+        from: VARIANT_TO_FROM_MAP.notifications,
+        to: email,
+        react: NewMessageFromProgram({
+          program: {
+            name: program.name,
+            logo: program.logo,
+            slug: program.slug,
+          },
+          messages: unreadMessages.map((message) => ({
+            text: message.text,
+            createdAt: message.createdAt,
+            user: message.senderUser.name
+              ? {
+                  name: message.senderUser.name,
+                  image: message.senderUser.image,
+                }
+              : {
+                  name: program.name,
+                  image: program.logo,
+                },
+          })),
-          messages: unreadMessages.map((message) => ({
-            text: message.text,
-            createdAt: message.createdAt,
-            user: message.senderUser.name
-              ? {
-                  name: message.senderUser.name,
-                  image: message.senderUser.image,
-                }
-              : {
-                  name: program.name,
-                  image: program.logo,
-                },
-          })),
+          messages: unreadMessages.map((message) => ({
+            text: message.text,
+            createdAt: message.createdAt,
+            user: message.senderUser?.name
+              ? {
+                  name: message.senderUser.name,
+                  image: message.senderUser.image,
+                }
+              : {
+                  name: program.name,
+                  image: program.logo,
+                },
+          })),
-          messages: unreadMessages.map((message) => ({
-            text: message.text,
-            createdAt: message.createdAt,
-            user: message.senderUser.name
-              ? {
-                  name: message.senderUser.name,
-                  image: message.senderUser.image,
-                }
-              : {
-                  name: program.name,
-                  image: program.logo,
-                },
-          })),
+          messages: unreadMessages.map((message) => ({
+            text: message.text,
+            createdAt: message.createdAt,
+            user: message.senderUser?.name
+              ? {
+                  name: message.senderUser.name,
+                  image: message.senderUser.image,
+                }
+              : {
+                  name: program.name,
+                  image: program.logo,
+                },
+          })),
+          email,
+        }),
+        tags: [{ name: "type", value: "message-notification" }],
+      })),
+    );
+
+    if (error)
+      throw new Error(
+        `Error sending message emails to partner ${partnerId}: ${error.message}`,
+      );
+
+    if (!data)
+      throw new Error(
+        `No data received from sending message emails to partner ${partnerId}`,
+      );
+
+    await prisma.notificationEmail.createMany({
+      data: unreadMessages.flatMap((message) =>
+        data.data.map(({ id }) => ({
+          type: NotificationEmailType.Message,
+          emailId: id,
+          messageId: message.id,
+        })),
+      ),
+    });
+
+    return logAndRespond(
+      `Emails sent for messages from program ${programId} to partner ${partnerId}.`,
+    );
+  } catch (error) {
+    await log({
+      message: `Error notifying partner of new messages: ${error.message}`,
+      type: "alerts",
+    });
+
+    return handleAndReturnErrorResponse(error);
+  }
+}
diff --git a/apps/web/app/(ee)/api/cron/messages/notify-program/route.ts b/apps/web/app/(ee)/api/cron/messages/notify-program/route.ts
@@ -0,0 +1,167 @@
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
+import { resend } from "@dub/email/resend";
+import { VARIANT_TO_FROM_MAP } from "@dub/email/resend/constants";
+import NewMessageFromPartner from "@dub/email/templates/new-message-from-partner";
+import { prisma } from "@dub/prisma";
+import { NotificationEmailType } from "@dub/prisma/client";
+import { log } from "@dub/utils";
+import { subDays } from "date-fns";
+import { z } from "zod";
+import { logAndRespond } from "../../utils";
+
+export const dynamic = "force-dynamic";
+
+const schema = z.object({
+  programId: z.string(),
+  partnerId: z.string(),
+  lastMessageId: z.string(),
+});
+
+// POST /api/cron/messages/notify-program
+// Notify a program about unread messages from a partner
+export async function POST(req: Request) {
+  try {
+    const rawBody = await req.text();
+
+    await verifyQstashSignature({
+      req,
+      rawBody,
+    });
+
+    const { programId, partnerId, lastMessageId } = schema.parse(
+      JSON.parse(rawBody),
+    );
+
+    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
+      where: {
+        partnerId_programId: {
+          partnerId,
+          programId,
+        },
+        status: "approved",
+      },
+      include: {
-    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
-      where: {
-        partnerId_programId: {
-          partnerId,
-          programId,
-        },
-        status: "approved",
-      },
-      include: {
+    const programEnrollment = await prisma.programEnrollment.findFirstOrThrow({
+      where: {
+        partnerId,
+        programId,
+        status: "approved",
+      },
+      include: {
-    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
-      where: {
-        partnerId_programId: {
-          partnerId,
-          programId,
-        },
-        status: "approved",
-      },
-      include: {
+    const programEnrollment = await prisma.programEnrollment.findFirstOrThrow({
+      where: {
+        partnerId,
+        programId,
+        status: "approved",
+      },
+      include: {
+        program: {
+          include: {
+            workspace: {
+              include: {
+                users: {
+                  include: {
+                    user: true,
+                  },
+                  where: {
+                    notificationPreference: {
+                      newMessageFromPartner: true,
+                    },
+                  },
-                  where: {
-                    notificationPreference: {
-                      newMessageFromPartner: true,
-                    },
-                  },
+                  where: {
+                    notificationPreferences: {
+                      newMessageFromPartner: true,
+                    },
+                  },
-                  where: {
-                    notificationPreference: {
-                      newMessageFromPartner: true,
-                    },
-                  },
+                  where: {
+                    notificationPreferences: {
+                      newMessageFromPartner: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        partner: {
+          include: {
+            messages: {
+              where: {
+                programId,
+                senderPartnerId: {
+                  not: null, // Sent by the partner
+                },
+                createdAt: {
+                  gt: subDays(new Date(), 3), // Sent in the last 3 days
+                },
+                readInApp: null, // Unread
+                readInEmail: null, // Unread
+                emails: {
+                  none: {}, // No emails sent yet
+                },
+              },
+              include: {
+                senderPartner: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const unreadMessages = programEnrollment.partner.messages.sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+    );
+
+    if (unreadMessages.length === 0)
+      return logAndRespond(
+        `No unread messages found from partner ${partnerId} in program ${programId}. Skipping...`,
+      );
+
+    if (unreadMessages[unreadMessages.length - 1].id !== lastMessageId)
+      return logAndRespond(
+        `There is a more recent unread message than ${lastMessageId}. Skipping...`,
+      );
+
+    const userEmailsToNotify = programEnrollment.program.workspace.users
+      .map(({ user }) => user.email)
+      .filter(Boolean) as string[];
+
+    if (userEmailsToNotify.length === 0)
+      return logAndRespond(
+        `No program user emails to notify from partner ${partnerId}. Skipping...`,
+      );
+
+    const { program, partner } = programEnrollment;
+
+    const { data, error } = await resend.batch.send(
+      userEmailsToNotify.map((email) => ({
+        subject: `${unreadMessages.length === 1 ? "New message from" : `${unreadMessages.length} new messages from`} ${partner.name}`,
+        from: VARIANT_TO_FROM_MAP.notifications,
+        to: email,
+        react: NewMessageFromPartner({
+          workspaceSlug: program.workspace.slug,
+          partner: {
+            id: partner.id,
+            name: partner.name,
+            image: partner.image,
+          },
+          messages: unreadMessages.map((message) => ({
+            text: message.text,
+            createdAt: message.createdAt,
+          })),
+          email,
+        }),
+        tags: [{ name: "type", value: "message-notification" }],
+      })),
+    );
+
+    if (error)
+      throw new Error(
+        `Error sending message emails to program ${programId} users: ${error.message}`,
+      );
+
+    if (!data)
+      throw new Error(
+        `No data received from sending message emails to program ${programId} users`,
+      );
+
+    await prisma.notificationEmail.createMany({
+      data: unreadMessages.flatMap((message) =>
+        data.data.map(({ id }) => ({
+          type: NotificationEmailType.Message,
+          emailId: id,
+          messageId: message.id,
+        })),
+      ),
+    });
-    await prisma.notificationEmail.createMany({
-      data: unreadMessages.flatMap((message) =>
-        data.data.map(({ id }) => ({
-          type: NotificationEmailType.Message,
-          emailId: id,
-          messageId: message.id,
-        })),
-      ),
-    });
+    await prisma.notificationEmail.createMany({
+      skipDuplicates: true,
+      data: unreadMessages.flatMap((message) =>
+        data.data.map(({ id }) => ({
+          type: NotificationEmailType.Message,
+          emailId: id,
+          messageId: message.id,
+        })),
+      ),
+    });
-    await prisma.notificationEmail.createMany({
-      data: unreadMessages.flatMap((message) =>
-        data.data.map(({ id }) => ({
-          type: NotificationEmailType.Message,
-          emailId: id,
-          messageId: message.id,
-        })),
-      ),
-    });
+    await prisma.notificationEmail.createMany({
+      skipDuplicates: true,
+      data: unreadMessages.flatMap((message) =>
+        data.data.map(({ id }) => ({
+          type: NotificationEmailType.Message,
+          emailId: id,
+          messageId: message.id,
+        })),
+      ),
+    });
+
+    return logAndRespond(
+      `Emails sent for messages from partner ${partnerId} to program ${programId} users.`,
+    );
+  } catch (error) {
+    await log({
+      message: `Error notifying program users of new messages: ${error.message}`,
+      type: "alerts",
+    });
+
+    return handleAndReturnErrorResponse(error);
+  }
+}
diff --git a/apps/web/app/(ee)/api/messages/count/route.ts b/apps/web/app/(ee)/api/messages/count/route.ts
@@ -0,0 +1,39 @@
+import { getDefaultProgramIdOrThrow } from "@/lib/api/programs/get-default-program-id-or-throw";
+import { withWorkspace } from "@/lib/auth";
+import { countMessagesQuerySchema } from "@/lib/zod/schemas/messages";
+import { prisma } from "@dub/prisma";
+import { NextResponse } from "next/server";
+
+// GET /api/messages/count - count messages for a program
+export const GET = withWorkspace(
+  async ({ workspace, searchParams }) => {
+    const programId = getDefaultProgramIdOrThrow(workspace);
+
+    const { unread } = countMessagesQuerySchema.parse(searchParams);
+
+    const count = await prisma.message.count({
+      where: {
+        programId,
+        ...(unread !== undefined && {
+          // Only count messages from the partner
+          senderPartnerId: {
+            not: null,
+          },
+          readInApp: unread
+            ? // Only count unread messages
+              null
+            : {
+                // Only count read messages
+                not: null,
+              },
+        }),
+      },
+    });
+
+    return NextResponse.json(count);
+  },
+  {
+    requiredPermissions: ["messages.read"],
+    requiredPlan: ["advanced", "enterprise"],
+  },
+);