feat: cron created, enrolment amends, schema amends and email created

Author: Logannford

prisma/migrations/20250304213753_adds_user_enrol_to_study_path_goal/migration.sql

@@ -0,0 +1,2 @@
+-- AddForeignKey
+ALTER TABLE "StudyPathGoal" ADD CONSTRAINT "StudyPathGoal_userUid_studyPathUid_fkey" FOREIGN KEY ("userUid", "studyPathUid") REFERENCES "UserStudyPath"("userUid", "studyPathUid") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20250304214550_adds_user_enrol_to_study_path_goal_fixes_uid/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "StudyPathGoal" ADD COLUMN     "userStudyPathUid" TEXT;

prisma/migrations/20250304215645_fixes_study_path_goal_user_study_path_relation/migration.sql

@@ -0,0 +1,5 @@
+-- DropForeignKey
+ALTER TABLE "StudyPathGoal" DROP CONSTRAINT "StudyPathGoal_userUid_studyPathUid_fkey";
+
+-- AddForeignKey
+ALTER TABLE "StudyPathGoal" ADD CONSTRAINT "StudyPathGoal_userStudyPathUid_fkey" FOREIGN KEY ("userStudyPathUid") REFERENCES "UserStudyPath"("uid") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/schema/study-path.prisma

@@ -28,8 +28,10 @@ model UserStudyPath {
   enrolledAt   DateTime  @default(now())
   completedAt  DateTime?
   progress     Float     @default(0)
+  
   studyPath    StudyPath @relation(fields: [studyPathUid], references: [uid], onDelete: Cascade)
   user         Users     @relation(fields: [userUid], references: [uid], onDelete: Cascade)
+  StudyPathGoal StudyPathGoal[]
 
   @@unique([userUid, studyPathUid])
 }
@@ -53,11 +55,14 @@ model StudyPathGoal {
 
   userUid      String
   studyPathUid String
+  userStudyPathUid String?
 
   // the study path the goal is for
   studyPath    StudyPath @relation(fields: [studyPathUid], references: [uid], onDelete: Cascade)
   // the user the goal is for
   user         Users     @relation(fields: [userUid], references: [uid], onDelete: Cascade)
+  // the users study path enrollment
+  userStudyPath UserStudyPath? @relation(fields: [userStudyPathUid], references: [uid], onDelete: Cascade)
 
   @@unique([userUid, studyPathUid])
 }

src/actions/misc/send-invite.ts

@@ -2,7 +2,7 @@
 
 import { resend } from '@/lib/resend';
 import { getUser } from '../user/authed/get-user';
-import ReferralEmail from '@/components/templates/referral';
+import ReferralEmail from '@/components/emails/referral';
 import { renderAsync } from '@react-email/components';
 import React from 'react';
 import { getUserMissionRecords } from '@/utils/data/missions/get-user-mission-record';

src/actions/study-paths/set-goal.ts

@@ -1,8 +1,9 @@
 'use server';
 import { prisma } from '@/lib/prisma';
 import { getUser } from '../user/authed/get-user';
-import { isUserEnrolledInStudyPath } from '@/utils/data/study-paths/get';
+import { getUserStudyPaths, isUserEnrolledInStudyPath } from '@/utils/data/study-paths/get';
 import { enrollInStudyPath } from './enroll';
+import { UserStudyPath } from '@prisma/client';
 
 export const setUserStudyPathGoal = async (studyPathUid: string, goal: Date) => {
   const user = await getUser();
@@ -18,36 +19,40 @@ export const setUserStudyPathGoal = async (studyPathUid: string, goal: Date) =>
   // check if the user has already set a goal for this study path
   const existingGoal = await prisma.studyPathGoal.findFirst({
     where: {
-      studyPathUid,
       userUid: user.uid,
+      studyPathUid: studyPathUid,
+      AND: {
+        completed: false,
+      },
     },
   });
 
   if (existingGoal) {
     return {
       success: false,
-      error: 'Goal already set',
+      error: 'You already have a goal set. Complete it before setting a new one.',
     };
   }
 
   // now check if the users is enrolled in the study path
-  const existingEnrollment = await isUserEnrolledInStudyPath(studyPathUid);
+  let existingEnrollment = await isUserEnrolledInStudyPath(studyPathUid);
 
   // if the user is not enrolled in the study path, enroll them
   if (!existingEnrollment) {
-    await enrollInStudyPath(studyPathUid);
+    existingEnrollment = await enrollInStudyPath(studyPathUid);
   }
 
   // now set the goal
   await prisma.studyPathGoal.create({
     data: {
-      studyPathUid,
-      userUid: user.uid,
       dateSet: new Date(),
       targetDate: goal,
       completed: false,
       completedAt: null,
       isActive: true,
+      userUid: user.uid,
+      studyPathUid: studyPathUid,
+      userStudyPathUid: existingEnrollment?.uid,
     },
   });
 

src/app/api/cron/challenges/send-suggested-challenge/route.ts

@@ -1,4 +1,4 @@
-import { SuggestedChallengeEmailTemplate } from '@/components/templates/daily-challenge';
+import { SuggestedChallengeEmailTemplate } from '@/components/emails/daily-challenge';
 import { prisma } from '@/lib/prisma';
 import { resend } from '@/lib/resend';
 import { QuestionWithTags } from '@/types/Questions';
@@ -14,6 +14,8 @@ import { type NextRequest, NextResponse } from 'next/server';
 import React from 'react';
 
 export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+export const maxDuration = 300; // 5 minutes
 
 const getRandomElement = (arr: string[]) => arr[Math.floor(Math.random() * arr.length)];
 
@@ -53,7 +55,7 @@ async function sendEmail(user: UserRecord, challenge: QuestionWithTags) {
   });
 }
 
-export async function GET(request: NextRequest) {
+export async function POST(request: NextRequest) {
   const authHeader = request.headers.get('authorization');
   if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
     return new Response('Unauthorized', {
@@ -64,25 +66,26 @@ export async function GET(request: NextRequest) {
   console.log('Sending daily challenge email');
 
   try {
-    const users = await prisma.users.findMany({
-      where: {
-        sendPushNotifications: true,
-      },
-    });
-
-    if (!users.length) {
-      return NextResponse.json({ message: 'No users found' }, { status: 404 });
-    }
-
-    // Process users in batches of 5 to avoid connection pool exhaustion
-    const batchSize = 5;
+    // Process users in larger batches with pagination
+    const batchSize = 50; // Increased from 5 to 50
     const results = [];
-
-    for (let i = 0; i < users.length; i += batchSize) {
-      const batch = users.slice(i, i + batchSize);
+    let skip = 0;
+
+    while (true) {
+      const users = await prisma.users.findMany({
+        where: {
+          sendPushNotifications: true,
+        },
+        take: batchSize,
+        skip,
+      });
+
+      if (!users.length) {
+        break;
+      }
 
       const batchResults = await Promise.allSettled(
-        batch.map(async (user) => {
+        users.map(async (user) => {
           try {
             const challenge = await getChallenge(user.uid);
             if (!challenge) {
@@ -103,10 +106,11 @@ export async function GET(request: NextRequest) {
       );
 
       results.push(...batchResults);
+      skip += batchSize;
 
-      // Add a small delay between batches to allow connections to be released
-      if (i + batchSize < users.length) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
+      // Add a smaller delay between batches to prevent rate limiting
+      if (skip < (await prisma.users.count({ where: { sendPushNotifications: true } }))) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
       }
     }
 

src/app/api/cron/goals/send-daily-goal-reminder/route.ts

@@ -0,0 +1,80 @@
+import { prisma } from '@/lib/prisma';
+import { isAuthorized } from '@/utils/cron';
+import { NextRequest, NextResponse } from 'next/server';
+import { resend } from '@/lib/resend';
+import { renderAsync } from '@react-email/components';
+import StudyReminderEmail from '@/components/emails/study-reminder';
+import React from 'react';
+import { UserRecord } from '@/types/User';
+import { StudyPath, StudyPathGoal, UserStudyPath } from '@prisma/client';
+import { getUserDisplayName } from '@/utils/user';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+export const maxDuration = 300; // 5 minutes
+
+type GoalWithRelations = StudyPathGoal & {
+  studyPath: StudyPath;
+  user: UserRecord;
+  userStudyPath: UserStudyPath;
+};
+
+async function SendEmail(goal: GoalWithRelations) {
+  const displayName = getUserDisplayName(goal.user);
+  const subject = `TechBlitz - Daily Goal Reminder`;
+  const link = `${process.env.NEXT_PUBLIC_URL}/roadmap/${goal.studyPathUid}`;
+
+  // calculate the days remaining by comparing the target date to the current date
+  const daysRemaining = Math.ceil(
+    (goal.targetDate.getTime() - new Date().getTime()) / (1000 * 60 * 60 * 24)
+  );
+
+  const html = await renderAsync(
+    React.createElement(StudyReminderEmail, {
+      userName: displayName,
+      studyPathTitle: goal.studyPath.title,
+      goalDate: goal.targetDate.toLocaleDateString(),
+      progressPercentage: goal.userStudyPath.progress.toFixed(2),
+      daysRemaining,
+      link,
+    })
+  );
+
+  await resend.emails.send({
+    from: 'TechBlitz <team@techblitz.dev>',
+    to: goal.user.email,
+    subject,
+    html,
+    replyTo: 'team@techblitz.dev',
+  });
+}
+
+export async function GET(request: NextRequest) {
+  if (!isAuthorized(request)) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  // get all users who have a goal
+  const goals = await prisma.studyPathGoal.findMany({
+    where: {
+      targetDate: {
+        gt: new Date(),
+      },
+      AND: {
+        completed: false,
+      },
+    },
+    include: {
+      user: true,
+      studyPath: true,
+      userStudyPath: true,
+    },
+  });
+
+  // loop through all users and send a reminder email
+  for (const goal of goals) {
+    await SendEmail(goal);
+  }
+
+  return NextResponse.json({ message: 'Reminders sent' }, { status: 200 });
+}