feat(notifications): add educational notifications

- Add Prisma schema updates: new EDUCATIONAL notification type, NotificationPriority and NotificationCategory enums, extend Notification model with priority and category fields
- Implement full educational notification system: template library, scheduled daily delivery job, personalized targeting based on pregnancy trimester and risk level, anti-spam fatigue rules
- Update inactivity monitoring logic to use 3-day threshold instead of 5, make reminder messages dynamic to show actual inactive day count
- Refactor existing notification templates to support dynamic content functions
- Add centralized NotificationOrchestratorService to handle all notification delivery, filtering, and dispatch
- Register new services in NotificationsModule and export orchestrator service

prisma/schema.prisma

@@ -265,25 +265,53 @@ enum NotificationType {
   BP_ALERT
   SYMPTOM_ALERT
   REMINDER
+  EDUCATIONAL
+}
+
+/**
+ * Notification Priority Enum
+ */
+enum NotificationPriority {
+  INFORMATIONAL
+  EDUCATIONAL
+  REMINDER
+  ELEVATED_RISK
+  CRITICAL
+}
+
+/**
+ * Notification Category Enum
+ */
+enum NotificationCategory {
+  PREECLAMPSIA_AWARENESS
+  BP_MONITORING
+  PREGNANCY_WARNING_SIGNS
+  HYDRATION
+  REST
+  ANTENATAL_CARE
+  SYMPTOM_AWARENESS
+  TRIMESTER_GUIDANCE
 }
 
 /**
  * Notification Entity
- * 
+ *
  * PURPOSE:
  * - Store history of alerts and notifications
  * - Track read status
  */
 model Notification {
-  id        String           @id @default(uuid())
+  id        String               @id @default(uuid())
   userId    String
   type      NotificationType
+  priority  NotificationPriority @default(REMINDER)
+  category  NotificationCategory?
   title     String
   message   String
-  read      Boolean          @default(false)
-  createdAt DateTime         @default(now())
-  
-  userAuth  UserAuth         @relation(fields: [userId], references: [id], onDelete: Cascade)
+  read      Boolean              @default(false)
+  createdAt DateTime             @default(now())
+
+  userAuth  UserAuth             @relation(fields: [userId], references: [id], onDelete: Cascade)
 
   @@index([userId])
   @@index([createdAt])

src/monitoring-engine/monitoring-scheduler.service.ts

@@ -66,7 +66,7 @@ export class MonitoringSchedulerService {
   async handleInactivity() {
     this.logger.log("Checking for user inactivity...");
     const now = new Date();
-    const fiveDaysAgo = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000);
+    const threeDaysAgo = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000);
     const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
 
     const users = await this.prisma.userAuth.findMany({
@@ -82,20 +82,22 @@ export class MonitoringSchedulerService {
     for (const user of users) {
       const lastBpReading = user.bloodPressureReadings[0];
       if (!lastBpReading) {
-        // No BP ever logged, send initial reminder after 5 days of account creation
+        // No BP ever logged, send initial reminder after 3 days of account creation
         try {
           const userProfile = await this.userProfileService.findByUserId(
             user.id,
           );
-          if (userProfile && userProfile.createdAt < fiveDaysAgo) {
+          if (userProfile && userProfile.createdAt < threeDaysAgo) {
+            const diffInMs = now.getTime() - userProfile.createdAt.getTime();
+            const daysInactive = Math.floor(diffInMs / (1000 * 60 * 60 * 24));
             await this.notificationsService.sendPushNotification(
               user.id,
               "BP Log Reminder",
-              "You haven't logged your blood pressure yet. Please log your first reading.",
+              `You haven't logged your blood pressure yet in ${daysInactive} days. Please log your first reading.`,
               { type: AppNotificationType.INACTIVITY_REMINDER },
             );
             this.logger.log(
-              `Inactivity reminder sent to user ${user.id} (no BP ever logged).`,
+              `Inactivity reminder sent to user ${user.id} (no BP ever logged, ${daysInactive} days).`,
             );
           }
         } catch (error) {
@@ -116,27 +118,31 @@ export class MonitoringSchedulerService {
         continue;
       }
 
+      // Calculate days inactive
+      const diffInMs = now.getTime() - lastBpReading.recordedAt.getTime();
+      const daysInactive = Math.floor(diffInMs / (1000 * 60 * 60 * 24));
+
       if (lastBpReading.recordedAt < sevenDaysAgo) {
         // No BP logged in >7 days -> escalate messaging urgency
         await this.notificationsService.sendPushNotification(
           user.id,
           "Urgent BP Reminder",
-          "It's been over 7 days since your last blood pressure reading. Please log it now.",
+          `It's been over ${daysInactive} days since your last blood pressure reading. Please log it now.`,
           { type: AppNotificationType.URGENT_INACTIVITY_REMINDER },
         );
         this.logger.warn(
-          `Urgent inactivity reminder sent to user ${user.id} (>7 days).`,
+          `Urgent inactivity reminder sent to user ${user.id} (${daysInactive} days).`,
         );
-      } else if (lastBpReading.recordedAt < fiveDaysAgo) {
-        // No BP logged in >5 days -> send reminder
+      } else if (lastBpReading.recordedAt < threeDaysAgo) {
+        // No BP logged in >3 days -> send reminder
         await this.notificationsService.sendPushNotification(
           user.id,
           "BP Log Reminder",
-          "It's been over 5 days since your last blood pressure reading. Please log it soon.",
+          `It's been over ${daysInactive} days since your last blood pressure reading. Please log it soon.`,
           { type: AppNotificationType.INACTIVITY_REMINDER },
         );
         this.logger.log(
-          `Inactivity reminder sent to user ${user.id} (>5 days).`,
+          `Inactivity reminder sent to user ${user.id} (${daysInactive} days).`,
         );
       }
     }

src/notifications/educational-scheduler.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { PrismaService } from '../database/prisma.service';
+import { NotificationOrchestratorService } from './notification-orchestrator.service';
+
+@Injectable()
+export class EducationalSchedulerService {
+  private readonly logger = new Logger(EducationalSchedulerService.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly notificationOrchestrator: NotificationOrchestratorService,
+  ) {}
+
+  /**
+   * Send educational notifications to active users
+   * Runs every day at 10 AM
+   */
+  @Cron('0 10 * * *')
+  async sendEducationalNotifications() {
+    this.logger.log('Starting educational notification job...');
+
+    try {
+      const activeUsers = await this.prisma.userAuth.findMany({
+        where: { isActive: true },
+        select: { id: true },
+      });
+
+      this.logger.log(
+        `Found ${activeUsers.length} active users to send educational notifications to`,
+      );
+
+      for (const user of activeUsers) {
+        try {
+          await this.notificationOrchestrator.sendEducationalNotification(user.id);
+        } catch (error) {
+          this.logger.error(
+            `Failed to send educational notification to user ${user.id}`,
+            error,
+          );
+        }
+      }
+
+      this.logger.log('Educational notification job completed successfully');
+    } catch (error) {
+      this.logger.error('Educational notification job failed', error);
+    }
+  }
+}

src/notifications/notification-orchestrator.service.ts

@@ -0,0 +1,323 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import {
+  NotificationType,
+  NotificationPriority,
+  NotificationCategory,
+  UserAuth,
+  UserProfile,
+} from '@prisma/client';
+import { EDUCATIONAL_TEMPLATES } from './templates/educational.templates';
+import { NotificationsService } from './notifications.service';
+
+export interface NotificationIntent {
+  userId: string;
+  type: NotificationType;
+  priority: NotificationPriority;
+  category?: NotificationCategory;
+  title: string;
+  body: string;
+  data?: any;
+}
+
+@Injectable()
+export class NotificationOrchestratorService {
+  private readonly logger = new Logger(NotificationOrchestratorService.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly notificationsService: NotificationsService,
+  ) {}
+
+  /**
+   * Main entry point for all notifications
+   */
+  async sendNotification(intent: NotificationIntent): Promise<void> {
+    this.logger.log(
+      `Processing notification intent for user ${intent.userId}: ${intent.title}`,
+    );
+
+    // 1. Check if user has notifications enabled (optional, based on user profile)
+    const user = await this.prisma.userAuth.findUnique({
+      where: { id: intent.userId },
+      include: { profile: true },
+    });
+
+    if (!user) {
+      this.logger.warn(`User ${intent.userId} not found, skipping notification`);
+      return;
+    }
+
+    // 2. Apply anti-spam/fatigue rules
+    const shouldSend = await this.shouldSendNotification(user, intent);
+    if (!shouldSend) {
+      this.logger.log(`Notification skipped for user ${intent.userId} due to fatigue rules`);
+      return;
+    }
+
+    // 3. Prioritize (critical notifications always go through)
+    if (intent.priority === NotificationPriority.CRITICAL) {
+      // Send immediately
+      await this.dispatchNotification(intent, user);
+      return;
+    }
+
+    // 4. Check for recent higher-priority notifications
+    const hasRecentHighPriority = await this.hasRecentHighPriorityNotification(
+      intent.userId,
+      intent.priority,
+    );
+    if (hasRecentHighPriority) {
+      this.logger.log(
+        `Notification skipped for user ${intent.userId} due to recent high-priority notifications`,
+      );
+      return;
+    }
+
+    // 5. Dispatch the notification
+    await this.dispatchNotification(intent, user);
+  }
+
+  /**
+   * Send an educational notification to a user
+   */
+  async sendEducationalNotification(userId: string): Promise<void> {
+    const user = await this.prisma.userAuth.findUnique({
+      where: { id: userId },
+      include: { profile: true },
+    });
+
+    if (!user?.profile) {
+      this.logger.warn(
+        `User ${userId} or profile not found, skipping educational notification`,
+      );
+      return;
+    }
+
+    // Get personalized templates
+    const eligibleTemplates = this.getPersonalizedTemplates(user.profile);
+
+    if (eligibleTemplates.length === 0) {
+      this.logger.log(`No eligible educational templates for user ${userId}`);
+      return;
+    }
+
+    // Pick a random template that hasn't been sent recently
+    const template = await this.pickUniqueTemplate(userId, eligibleTemplates);
+
+    if (!template) {
+      this.logger.log(`No unique educational templates available for user ${userId}`);
+      return;
+    }
+
+    const intent: NotificationIntent = {
+      userId,
+      type: NotificationType.EDUCATIONAL,
+      priority: NotificationPriority.EDUCATIONAL,
+      category: template.category,
+      title: template.title,
+      body: template.body,
+      data: { type: 'EDUCATIONAL', category: template.category },
+    };
+
+    await this.sendNotification(intent);
+  }
+
+  /**
+   * Get templates personalized to user's profile
+   */
+  private getPersonalizedTemplates(profile: UserProfile) {
+    const trimester = this.getTrimester(profile.pregnancyWeeks);
+    const hasHighRisk = this.hasHighRiskConditions(profile);
+
+    return EDUCATIONAL_TEMPLATES.filter((template) => {
+      // Filter by trimester
+      if (template.trimesters && !template.trimesters.includes(trimester)) {
+        return false;
+      }
+      // Filter by risk level (simplified)
+      if (template.riskLevels) {
+        const userRiskLevel = hasHighRisk ? 'high' : 'low';
+        if (!template.riskLevels.includes(userRiskLevel)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Determine user's trimester based on pregnancy weeks
+   */
+  private getTrimester(weeks: number): number {
+    if (weeks <= 13) return 1;
+    if (weeks <= 27) return 2;
+    return 3;
+  }
+
+  /**
+   * Check if user has high-risk conditions
+   */
+  private hasHighRiskConditions(profile: UserProfile): boolean {
+    return profile.knownConditions.some(
+      (condition) =>
+        condition === 'CHRONIC_HYPERTENSION' ||
+        condition === 'PREECLAMPSIA_HISTORY' ||
+        condition === 'KIDNEY_DISEASE',
+    );
+  }
+
+  /**
+   * Pick a unique template that hasn't been sent recently
+   */
+  private async pickUniqueTemplate(
+    userId: string,
+    templates: typeof EDUCATIONAL_TEMPLATES,
+  ): Promise<(typeof EDUCATIONAL_TEMPLATES)[0] | null> {
+    // Get recent educational notifications (last 7 days)
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+    const recentNotifications = await this.prisma.notification.findMany({
+      where: {
+        userId,
+        type: NotificationType.EDUCATIONAL,
+        createdAt: { gte: sevenDaysAgo },
+      },
+      select: { category: true, message: true },
+    });
+
+    // Filter out templates that have been sent recently
+    const availableTemplates = templates.filter((template) => {
+      return !recentNotifications.some(
+        (notif) => notif.message === template.body,
+      );
+    });
+
+    if (availableTemplates.length === 0) {
+      // If all templates have been used recently, pick any
+      return templates[Math.floor(Math.random() * templates.length)];
+    }
+
+    return availableTemplates[Math.floor(Math.random() * availableTemplates.length)];
+  }
+
+  /**
+   * Apply anti-spam/fatigue rules
+   */
+  private async shouldSendNotification(
+    user: UserAuth & { profile?: UserProfile | null },
+    intent: NotificationIntent,
+  ): Promise<boolean> {
+    // Critical notifications always go through
+    if (intent.priority === NotificationPriority.CRITICAL) {
+      return true;
+    }
+
+    // Check nighttime suppression (22:00 - 06:00)
+    const now = new Date();
+    const hour = now.getHours();
+    if (hour >= 22 || hour < 6) {
+      if (intent.priority !== NotificationPriority.ELEVATED_RISK) {
+        return false;
+      }
+    }
+
+    // Check recent notifications of the same category
+    if (intent.category) {
+      const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
+      const recentSameCategory = await this.prisma.notification.count({
+        where: {
+          userId: intent.userId,
+          category: intent.category,
+          createdAt: { gte: oneHourAgo },
+        },
+      });
+      if (recentSameCategory > 0) {
+        return false;
+      }
+    }
+
+    // Limit educational notifications to max 2 per day
+    if (intent.type === NotificationType.EDUCATIONAL) {
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const todayEducationalCount = await this.prisma.notification.count({
+        where: {
+          userId: intent.userId,
+          type: NotificationType.EDUCATIONAL,
+          createdAt: { gte: today },
+        },
+      });
+      if (todayEducationalCount >= 2) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Check for recent higher-priority notifications
+   */
+  private async hasRecentHighPriorityNotification(
+    userId: string,
+    currentPriority: NotificationPriority,
+  ): Promise<boolean> {
+    const priorityOrder = [
+      NotificationPriority.INFORMATIONAL,
+      NotificationPriority.EDUCATIONAL,
+      NotificationPriority.REMINDER,
+      NotificationPriority.ELEVATED_RISK,
+      NotificationPriority.CRITICAL,
+    ];
+
+    const currentIndex = priorityOrder.indexOf(currentPriority);
+    const higherPriorities = priorityOrder.slice(currentIndex + 1);
+
+    if (higherPriorities.length === 0) return false;
+
+    const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000);
+    const count = await this.prisma.notification.count({
+      where: {
+        userId,
+        priority: { in: higherPriorities },
+        createdAt: { gte: twoHoursAgo },
+      },
+    });
+
+    return count > 0;
+  }
+
+  /**
+   * Dispatch the notification (save to DB and send push)
+   */
+  private async dispatchNotification(
+    intent: NotificationIntent,
+    user: UserAuth,
+  ): Promise<void> {
+    // Save to database
+    await this.prisma.notification.create({
+      data: {
+        userId: intent.userId,
+        type: intent.type,
+        priority: intent.priority,
+        category: intent.category,
+        title: intent.title,
+        message: intent.body,
+      },
+    });
+
+    // Send push notification
+    if (user.pushToken) {
+      await this.notificationsService.sendPushNotification(
+        intent.userId,
+        intent.title,
+        intent.body,
+        intent.data,
+      );
+    }
+
+    this.logger.log(
+      `Notification dispatched to user ${intent.userId}: ${intent.title}`,
+    );
+  }
+}

src/notifications/notifications.module.ts

@@ -1,5 +1,7 @@
 import { Module } from "@nestjs/common";
 import { NotificationsService } from "./notifications.service";
+import { NotificationOrchestratorService } from "./notification-orchestrator.service";
+import { EducationalSchedulerService } from "./educational-scheduler.service";
 import { NotificationsController } from "./notifications.controller";
 import { EmailModule } from "../email/email.module";
 
@@ -10,6 +12,8 @@ import { EmailModule } from "../email/email.module";
  * - Send care escalation alerts
  * - Template-based messaging only
  * - No dynamic medical text generation
+ * - Centralized notification orchestration
+ * - Educational engagement notifications
  *
  * CLINICAL SAFETY CONSTRAINTS:
  * - No fear-based language
@@ -18,15 +22,18 @@ import { EmailModule } from "../email/email.module";
  * - Clear, actionable guidance
  *
  * DELIVERY:
- * - Currently stub implementation (console logging)
- * - Ready for integration with email/SMS services
- * - Examples: SendGrid, Twilio, AWS SNS
+ * - Push notifications via Expo
+ * - Email
  */
 
 @Module({
   imports: [EmailModule],
   controllers: [NotificationsController],
-  providers: [NotificationsService],
-  exports: [NotificationsService],
+  providers: [
+    NotificationsService,
+    NotificationOrchestratorService,
+    EducationalSchedulerService,
+  ],
+  exports: [NotificationsService, NotificationOrchestratorService],
 })
 export class NotificationsModule {}

src/notifications/notifications.service.ts

@@ -4,7 +4,7 @@ import { Cron, CronExpression } from "@nestjs/schedule";
 import { PrismaService } from "../database/prisma.service";
 import { EmailService } from "../email/email.service";
 import { CarePriority } from "../care-priority/types/care-priority.types";
-import { NotificationType } from "@prisma/client";
+import { NotificationType, NotificationPriority } from "@prisma/client";
 import type { ExpoPushMessage } from "expo-server-sdk";
 import {
   CARE_PRIORITY_TEMPLATES,
@@ -15,6 +15,7 @@ import {
   TREND_ALERT_TEMPLATES,
 } from "./templates/notification.templates";
 import { generateEmailHtml } from "./templates/email.template";
+import { NotificationOrchestratorService, NotificationIntent } from "./notification-orchestrator.service";
 
 /**
  * Notification Service
@@ -37,6 +38,7 @@ export class NotificationsService {
     private readonly prisma: PrismaService,
     private readonly emailService: EmailService,
     private readonly configService: ConfigService,
+    private readonly notificationOrchestrator: NotificationOrchestratorService,
   ) {}
 
   /**
@@ -201,38 +203,74 @@ export class NotificationsService {
   }
 
   /**
-   * Inactivity Monitor - Checks for users who haven't logged BP in 5 days
+   * Inactivity Monitor - Checks for users who haven't logged BP in 3 days or more
    * Runs daily at midnight
    */
   @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
   async checkInactivity() {
     this.logger.log("Running inactivity check...");
-    const fiveDaysAgo = new Date();
-    fiveDaysAgo.setDate(fiveDaysAgo.getDate() - 5);
+    const threeDaysAgo = new Date();
+    threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
 
-    // Find users whose last reading was > 5 days ago or who never logged
+    // Find users whose last reading was > 3 days ago or who never logged
     const users = await this.prisma.userAuth.findMany({
       where: {
         isActive: true,
         bloodPressureReadings: {
           none: {
-            recordedAt: { gte: fiveDaysAgo },
+            recordedAt: { gte: threeDaysAgo },
           },
         },
       },
-      select: { id: true, email: true },
+      select: { 
+        id: true, 
+        email: true, 
+        bloodPressureReadings: {
+          orderBy: { recordedAt: "desc" },
+          take: 1,
+          select: { recordedAt: true }
+        },
+        profile: {
+          select: { createdAt: true }
+        }
+      },
     });
 
     for (const user of users) {
       try {
-        if (await this.hasLoggedBPSince(user.id, fiveDaysAgo)) continue;
+        if (await this.hasLoggedBPSince(user.id, threeDaysAgo)) continue;
+        
+        // Calculate days inactive
+        const lastReading = user.bloodPressureReadings[0];
+        let daysInactive: number;
+        
+        if (lastReading) {
+          const now = new Date();
+          const diffInMs = now.getTime() - lastReading.recordedAt.getTime();
+          daysInactive = Math.floor(diffInMs / (1000 * 60 * 60 * 24));
+        } else if (user.profile?.createdAt) {
+          // Never logged, use days since profile creation
+          const now = new Date();
+          const diffInMs = now.getTime() - user.profile.createdAt.getTime();
+          daysInactive = Math.floor(diffInMs / (1000 * 60 * 60 * 24));
+        } else {
+          daysInactive = 3; // Fallback
+        }
+
+        // Ensure minimum 3 days
+        if (daysInactive < 3) continue;
+
         const template = MONITORING_TEMPLATES.INACTIVITY_REMINDER;
+        const body = typeof template.body === 'function' 
+          ? template.body(daysInactive) 
+          : template.body;
+
         await this.prisma.notification.create({
           data: {
             userId: user.id,
             type: NotificationType.REMINDER,
             title: template.subject,
-            message: template.body,
+            message: body,
           },
         });
 
@@ -240,7 +278,7 @@ export class NotificationsService {
         await this.sendPushNotification(
           user.id,
           template.subject,
-          template.body,
+          body,
           { type: "INACTIVITY_REMINDER" },
         );
 
@@ -248,7 +286,7 @@ export class NotificationsService {
         if (user.email) {
           const html = generateEmailHtml(
             template.subject,
-            template.body,
+            body,
             "Log BP Reading",
             `${this.configService.get("FRONTEND_URL")}/bridge?type=inactivity-reminder`,
             "#2DE474",
@@ -257,7 +295,7 @@ export class NotificationsService {
           await this.emailService.sendEmail(
             user.email,
             template.subject,
-            template.body,
+            body,
             html,
           );
         }

src/notifications/templates/educational.templates.ts

@@ -0,0 +1,112 @@
+import { NotificationCategory } from '@prisma/client';
+
+export interface EducationalTemplate {
+  title: string;
+  body: string;
+  category: NotificationCategory;
+  trimesters?: number[]; // 1, 2, 3
+  riskLevels?: string[]; // 'low', 'high'
+}
+
+export const EDUCATIONAL_TEMPLATES: EducationalTemplate[] = [
+  // PREECLAMPSIA_AWARENESS
+  {
+    title: 'Know the Signs',
+    body: 'Regular blood pressure checks help detect preeclampsia early.',
+    category: NotificationCategory.PREECLAMPSIA_AWARENESS,
+    trimesters: [2, 3],
+  },
+  {
+    title: 'Stay Informed',
+    body: 'Preeclampsia usually develops after 20 weeks of pregnancy.',
+    category: NotificationCategory.PREECLAMPSIA_AWARENESS,
+    trimesters: [2, 3],
+  },
+
+  // BP_MONITORING
+  {
+    title: 'Check In',
+    body: 'Consistent blood pressure monitoring helps you stay on top of your health.',
+    category: NotificationCategory.BP_MONITORING,
+  },
+  {
+    title: 'Quick Tip',
+    body: 'Rest for 5 minutes before checking your blood pressure for accurate results.',
+    category: NotificationCategory.BP_MONITORING,
+  },
+  {
+    title: 'Your Routine',
+    body: 'Logging your blood pressure regularly helps your care team understand your health better.',
+    category: NotificationCategory.BP_MONITORING,
+  },
+
+  // PREGNANCY_WARNING_SIGNS
+  {
+    title: 'Be Aware',
+    body: 'Swelling and headaches during pregnancy shouldn’t always be ignored.',
+    category: NotificationCategory.PREGNANCY_WARNING_SIGNS,
+  },
+  {
+    title: 'When to Check In',
+    body: 'If you have persistent headaches or vision changes, contact your healthcare provider.',
+    category: NotificationCategory.PREGNANCY_WARNING_SIGNS,
+  },
+
+  // HYDRATION
+  {
+    title: 'Stay Hydrated',
+    body: 'Drinking enough water helps support a healthy pregnancy.',
+    category: NotificationCategory.HYDRATION,
+  },
+  {
+    title: 'Water Break',
+    body: 'Aim for 8-10 glasses of water daily to stay hydrated.',
+    category: NotificationCategory.HYDRATION,
+  },
+
+  // REST
+  {
+    title: 'Take It Easy',
+    body: 'Getting enough rest is important for you and your baby.',
+    category: NotificationCategory.REST,
+  },
+  {
+    title: 'Rest Up',
+    body: 'Try to rest on your left side to improve blood flow to your baby.',
+    category: NotificationCategory.REST,
+  },
+
+  // ANTENATAL_CARE
+  {
+    title: 'Your Appointments',
+    body: 'Attending all your antenatal appointments helps ensure a healthy pregnancy.',
+    category: NotificationCategory.ANTENATAL_CARE,
+  },
+
+  // SYMPTOM_AWARENESS
+  {
+    title: 'Listen to Your Body',
+    body: 'If you notice any unusual symptoms, don’t hesitate to contact your healthcare provider.',
+    category: NotificationCategory.SYMPTOM_AWARENESS,
+  },
+
+  // TRIMESTER_GUIDANCE
+  {
+    title: 'First Trimester',
+    body: 'The first trimester is a time of rapid development for your baby.',
+    category: NotificationCategory.TRIMESTER_GUIDANCE,
+    trimesters: [1],
+  },
+  {
+    title: 'Second Trimester',
+    body: 'You may start feeling your baby move during the second trimester.',
+    category: NotificationCategory.TRIMESTER_GUIDANCE,
+    trimesters: [2],
+  },
+  {
+    title: 'Third Trimester',
+    body: 'In the third trimester, your baby is growing quickly and preparing for birth.',
+    category: NotificationCategory.TRIMESTER_GUIDANCE,
+    trimesters: [3],
+  },
+];

src/notifications/templates/notification.templates.ts

@@ -106,7 +106,7 @@ export const AUTH_TEMPLATES = {
 export const MONITORING_TEMPLATES = {
   INACTIVITY_REMINDER: {
     subject: "It's Been a While",
-    body: "We haven't seen a blood pressure entry from you in 5 days. Regular logging is key to a healthy pregnancy.",
+    body: (days: number) => `We haven't seen a blood pressure entry from you in ${days} days. Regular logging is key to a healthy pregnancy.`,
     callToAction: "Log your BP now to stay on track.",
   },