Initial backend deployment with Docker and Cron jobs

.dockerignore

@@ -0,0 +1,11 @@
+node_modules
+dist
+npm-debug.log
+Dockerfile
+.dockerignore
+.git
+.env
+README.md
+test
+coverage
+prisma/migrations

.env.example

@@ -0,0 +1,23 @@
+# Application
+NODE_ENV=development
+PORT=3000
+
+# Database (PostgreSQL) - Prisma Connection String
+DATABASE_URL="postgresql://postgres:your_password_here@localhost:5432/maternal_health?schema=public"
+
+# JWT Authentication
+JWT_SECRET=your_jwt_secret_here_change_in_production
+JWT_EXPIRATION=1h
+JWT_REFRESH_SECRET=your_refresh_secret_here_change_in_production
+JWT_REFRESH_EXPIRATION=7d
+
+# Frontend Configuration
+FRONTEND_URL=http://localhost:8081
+
+# Email Configuration (SMTP)
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-password
+SMTP_FROM=MaternAlert <no-reply@maternalert.com>
+

.gitignore

@@ -0,0 +1,46 @@
+# compiled output
+/dist
+/node_modules
+
+# Logs
+logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# Environment
+# .env
+.env.local
+.env.*.local
+
+/generated/prisma
+
+# Firebase Service Account
+*-firebase-adminsdk-*.json
+google-services.json

DEPLOYMENT.md

@@ -0,0 +1,40 @@
+# MaternAlert Backend Deployment Guide (Hugging Face Spaces)
+
+This guide covers the deployment of the MaternAlert backend as a persistent, Docker-based environment on Hugging Face Spaces. This setup ensures 99.9% uptime for background tasks and cron jobs.
+
+## 🚀 Deployment Steps
+
+### 1. Prepare Hugging Face Space
+1. Create a new Space on [Hugging Face](https://huggingface.co/new-space).
+2. Choose **Docker** as the SDK.
+3. Select the **Blank** template or **NestJS** if available.
+4. Choose your hardware (the free tier is sufficient for this backend).
+
+### 2. Configure Environment Variables
+In your Space settings, add the following secrets:
+- `DATABASE_URL`: Your production PostgreSQL connection string.
+- `JWT_SECRET`: A strong secret for token signing.
+- `EXPO_ACCESS_TOKEN`: Your Expo access token for push notifications.
+- `EMAIL_HOST`, `EMAIL_PORT`, `EMAIL_USER`, `EMAIL_PASS`: SMTP credentials for email alerts.
+- `FRONTEND_URL`: The URL of your deployed frontend.
+
+### 3. Deploy Code
+1. Clone the Space repository.
+2. Copy the contents of the `maternalert-be` directory into the Space repository.
+3. Ensure the `Dockerfile` and `.dockerignore` are in the root of the Space repository.
+4. Push your changes to the Space.
+
+## 🕒 Scheduled Tasks (Cron Jobs)
+The backend is configured with `@nestjs/schedule` to run the following persistent tasks:
+- **Daily Inactivity Check**: Runs at midnight to remind users who haven't logged BP in 5 days.
+- **Trend Analysis**: Runs daily at 1 AM to detect dangerous BP patterns.
+- **4-Hour Follow-Up**: Runs every 30 minutes to check for missed rechecks after elevated readings.
+
+## 🏥 Health & Monitoring
+- **Health Endpoint**: Access `https://your-space-url/api/v1/health` to verify service status and uptime.
+- **Logs**: Monitor execution logs directly in the Hugging Face Space "Logs" tab.
+
+## 🛠 Troubleshooting
+- **Cold Starts**: Hugging Face Spaces stay active as long as they receive traffic or are configured as "Persistent." Ensure the Space is set to "Public" or "Private" with persistence enabled.
+- **Database Connectivity**: Verify that your database allows connections from the Hugging Face IP range.
+- **Permissions**: The Dockerfile is configured to run as a non-root user (UID 1000) as required by Hugging Face.

Dockerfile

@@ -0,0 +1,40 @@
+# Build stage
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Install dependencies first (better caching)
+COPY package*.json ./
+COPY prisma ./prisma/
+
+RUN npm install
+
+# Copy source and build
+COPY . .
+RUN npx prisma generate
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Create a non-root user for security (Hugging Face requirement)
+RUN adduser -D -u 1000 appuser
+USER appuser
+
+# Copy built assets and production dependencies
+COPY --from=builder /app/package*.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/prisma ./prisma
+
+# Set production environment
+ENV NODE_ENV=production
+ENV PORT=7860
+
+# Expose the port (Hugging Face default is 7860)
+EXPOSE 7860
+
+# Run the app
+CMD ["npm", "run", "start:prod"]

README.md

@@ -1,11 +1,169 @@
----
-title: MaternAlert
-emoji: 👁
-colorFrom: gray
-colorTo: indigo
-sdk: docker
-pinned: false
-short_description: 'Clinical-safe maternal health support backend '
+# Maternal Health Support Backend
+
+⚠️ **CLINICAL SAFETY NOTICE**
+
+This application is a **CARE-SUPPORT and ESCALATION TOOL**.
+
+- ❌ This is **NOT** a diagnostic system
+- ❌ This is **NOT** a medical device
+- ✅ This **IS** a care-support and escalation tool for early warning awareness
+
+## Purpose
+
+This backend supports a maternal health application focused on:
+- Early warning awareness for high blood pressure disorders in pregnancy
+- Care escalation based on objective measurements
+- Educational content delivery
+- Connection to healthcare providers
+
+## Non-Diagnostic Design Principles
+
+This system is built with strict clinical safety constraints:
+
+1. **No Diagnosis**: The system never diagnoses conditions
+2. **No Medical Advice**: No treatment recommendations or medical guidance
+3. **No Risk Scoring**: No probability calculations or risk percentages
+4. **Data Minimization**: Only essential data is collected
+5. **Escalation Bias**: When uncertain, always escalate to higher priority
+6. **Template-Only Messaging**: No dynamic medical text generation
+
+## Architecture
+
+### Modular Domain-Driven Design
+
+```
+src/
+├── auth/                 # Authentication (minimal PII)
+├── user-profile/         # User profile (data minimization)
+├── blood-pressure/       # BP readings (neutral storage)
+├── symptoms/             # Symptom tracking (atomic, non-scored)
+├── care-priority/        # Care priority engine (rule-based)
+├── notifications/        # Alerts (template-only)
+└── education/            # Educational content
+```
+
+### Technology Stack
+
+- **Framework**: NestJS with TypeScript (strict mode)
+- **Database**: PostgreSQL (to be configured in STEP 2)
+- **Authentication**: JWT-based
+- **Validation**: class-validator with strict settings
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 18+ 
+- PostgreSQL 14+
+- npm or yarn
+
+### Installation
+
+```bash
+# Install dependencies
+npm install
+
+# Copy environment template
+cp .env.example .env
+
+# Edit .env with your configuration
+# (Database credentials, JWT secrets, etc.)
+```
+
+### Development
+
+```bash
+# Start in development mode with hot reload
+npm run start:dev
+
+# Build for production
+npm run build
+
+# Start production server
+npm run start:prod
+```
+
+### Testing
+
+```bash
+# Run unit tests
+npm test
+
+# Run tests in watch mode
+npm test:watch
+
+# Generate coverage report
+npm test:cov
+```
+
+## Deployment
+
+For persistent background tasks and cron jobs, the backend is optimized for deployment on **Hugging Face Spaces** using Docker.
+
+- [Deployment Guide](./DEPLOYMENT.md)
+- [Health Check API](http://localhost:3000/api/v1/health) (when running locally)
+
+## Implementation Status
+
+This project follows a 12-step implementation process:
+
+### Phase 1: Foundation
+- [x] **STEP 1**: Project Bootstrap & Architecture ✅
+- [ ] **STEP 2**: Database & ORM Setup
+- [ ] **STEP 3**: Authentication Module
+
+### Phase 2: Core Data Modules
+- [ ] **STEP 4**: User Profile Module (Data Minimization)
+- [ ] **STEP 5**: Blood Pressure Module (Neutral Handling)
+- [ ] **STEP 6**: Symptom Module (Atomic, Non-Scored)
+
+### Phase 3: Care Logic & Safety
+- [ ] **STEP 7**: Care Priority Engine (Most Critical)
+- [ ] **STEP 8**: Care Priority API Endpoint
+- [ ] **STEP 9**: Notifications & Alerts
+
+### Phase 4: Support & Security
+- [ ] **STEP 10**: Education Content Module
+- [ ] **STEP 11**: Security, Logging & Rate Limiting
+- [ ] **STEP 12**: Final Safety Audit
+
+## API Documentation
+
+Once running, API documentation will be available at:
+- Development: `http://localhost:3000/api/v1`
+- Swagger docs: (to be added in later steps)
+
+## Clinical Safety Commitments
+
+Every module in this system adheres to:
+
+1. **Deterministic Logic**: No AI/ML for medical decisions
+2. **Transparent Rules**: All escalation rules are documented
+3. **Conservative Defaults**: Favor care-seeking when uncertain
+4. **Audit Trail**: All decisions are logged (without PII)
+5. **No Diagnostic Language**: Careful wording throughout
+
+## Regulatory Considerations
+
+This system is designed for:
+- NGO deployments
+- Public health pilots
+- Clinical partnerships
+- Research studies
+
+**Not intended for**:
+- Direct-to-consumer medical diagnosis
+- Replacement of clinical judgment
+- Unsupervised medical decision-making
+
+## License
+
+ISC
+
+## Support
+
+For questions about clinical safety design or implementation, please review the inline documentation in each module.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Remember**: This is a care-support tool. Always encourage users to seek professional medical advice.

nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package.json

@@ -0,0 +1,75 @@
+{
+  "name": "maternal-health-backend",
+  "version": "1.0.0",
+  "description": "Clinical-safe maternal health support backend - Care escalation tool (NOT a diagnostic system)",
+  "main": "dist/main.js",
+  "scripts": {
+    "build": "prisma generate && prisma migrate deploy && nest build",
+    "postinstall": "prisma generate",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "prisma:generate": "prisma generate",
+    "prisma:migrate": "prisma migrate dev",
+    "prisma:studio": "prisma studio",
+    "prisma:push": "prisma db push"
+  },
+  "keywords": [
+    "maternal-health",
+    "pregnancy",
+    "hypertension",
+    "care-escalation",
+    "clinical-safety"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@nestjs/cli": "^11.0.14",
+    "@nestjs/schematics": "^11.0.9",
+    "@nestjs/testing": "^11.1.11",
+    "@types/bcrypt": "^6.0.0",
+    "@types/compression": "^1.8.1",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.0.6",
+    "@types/nodemailer": "^7.0.11",
+    "@types/passport-jwt": "^4.0.1",
+    "@types/pg": "^8.16.0",
+    "dotenv": "^17.2.3",
+    "prisma": "^7.2.0",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@googlemaps/google-maps-services-js": "^3.4.2",
+    "@nestjs/config": "^4.0.2",
+    "@nestjs/jwt": "^11.0.2",
+    "@nestjs/passport": "^11.0.5",
+    "@nestjs/platform-express": "^11.1.11",
+    "@nestjs/schedule": "^6.1.1",
+    "@nestjs/swagger": "^11.2.4",
+    "@nestjs/throttler": "^6.5.0",
+    "@prisma/adapter-pg": "^7.2.0",
+    "@prisma/client": "^7.2.0",
+    "axios": "^1.13.5",
+    "bcrypt": "^6.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
+    "compression": "^1.8.1",
+    "expo-server-sdk": "^6.1.0",
+    "helmet": "^8.1.0",
+    "nodemailer": "^8.0.1",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "pg": "^8.16.3",
+    "swagger-ui-express": "^5.0.1"
+  }
+}

prisma.config.ts

@@ -0,0 +1,14 @@
+// This file was generated by Prisma, and assumes you have installed the following:
+// npm install --save-dev prisma dotenv
+import "dotenv/config";
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: process.env["DATABASE_URL"],
+  },
+});

prisma/schema.prisma

@@ -0,0 +1,282 @@
+/**
+ * Prisma Schema for Maternal Health Support Backend
+ * 
+ * ORM CHOICE: Prisma
+ * 
+ * JUSTIFICATION:
+ * - Type-safe database client with excellent TypeScript support
+ * - Intuitive schema definition language
+ * - Automatic migration generation
+ * - Built-in connection pooling
+ * - Great developer experience with Prisma Studio
+ * - Strong PostgreSQL support
+ * 
+ * CLINICAL SAFETY PRINCIPLES:
+ * - Data minimization enforced at schema level
+ * - No free-text medical fields
+ * - Enums for controlled vocabularies
+ * - Timestamps for audit trails
+ * - Strict validation rules
+ */
+
+generator client {
+  provider   = "prisma-client-js"
+  engineType = "library"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+/**
+ * UserAuth Entity
+ * 
+ * CLINICAL SAFETY CONSTRAINTS:
+ * - Minimal PII only (email OR phone, not both required)
+ * - No health data in this table
+ * - No logging of credentials
+ * - Passwords are hashed (never stored in plain text)
+ * 
+ * DATA MINIMIZATION:
+ * - Only authentication-related fields
+ * - No names, addresses, or demographic data
+ * - Health data stored in separate UserProfile table
+ */
+model UserAuth {
+  id            String   @id @default(uuid())
+  email         String?  @unique
+  phone         String?  @unique
+  passwordHash  String   // bcrypt hashed password
+  refreshToken  String?  // For JWT refresh token rotation
+  pushToken     String?  // For Expo push notifications
+  resetPasswordToken   String?  // For forgot password
+  resetPasswordExpires DateTime? // For forgot password
+  isActive      Boolean  @default(true)
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  // Relation to UserProfile (optional - created after registration)
+  profile       UserProfile?
+
+  // Relation to BloodPressureReadings
+  bloodPressureReadings BloodPressureReading[]
+
+  // Relation to SymptomRecords
+  symptomRecords SymptomRecord[]
+
+  // Relation to Notifications
+  notifications Notification[]
+
+  @@index([email])
+  @@index([phone])
+  @@map("user_auth")
+}
+
+/**
+ * Age Range Enum
+ * 
+ * DATA MINIMIZATION:
+ * - Use age ranges instead of exact DOB
+ * - Prevents unnecessary PII collection
+ */
+enum AgeRange {
+  UNDER_18
+  AGE_18_34
+  AGE_35_PLUS
+}
+
+/**
+ * Emergency Contact Relationship Enum
+ *
+ * DATA MINIMIZATION:
+ * - Relationship type only (no names stored)
+ * - Supports midwife or closest relative
+ */
+enum EmergencyContactRelationship {
+  MIDWIFE
+  PARTNER
+  FAMILY_MEMBER
+  OTHER
+}
+
+/**
+ * Known Conditions Enum
+ * 
+ * CLINICAL SAFETY:
+ * - Enumerated list prevents free-text medical history
+ * - Only high-risk pregnancy conditions relevant to hypertension
+ * - No diagnostic information stored
+ */
+enum KnownCondition {
+  CHRONIC_HYPERTENSION
+  GESTATIONAL_DIABETES
+  PREECLAMPSIA_HISTORY
+  KIDNEY_DISEASE
+  AUTOIMMUNE_DISORDER
+  MULTIPLE_PREGNANCY
+  NONE
+}
+
+/**
+ * UserProfile Entity
+ * 
+ * DATA MINIMIZATION PRINCIPLES:
+ * - No DOB (age range only)
+ * - No address
+ * - No free-text medical history
+ * - No name or demographic data
+ * - Only pregnancy-relevant information
+ * 
+ * CLINICAL SAFETY:
+ * - All fields are enumerated or structured
+ * - No diagnostic interpretations stored
+ * - Links to UserAuth via userId
+ */
+model UserProfile {
+  id                String           @id @default(uuid())
+  userId            String           @unique
+  ageRange          AgeRange
+  pregnancyWeeks    Int              // Current week of pregnancy (0-42)
+  firstPregnancy    Boolean
+  knownConditions   KnownCondition[] // Array of enumerated conditions
+  emergencyContactPhone         String?                       // Phone number only (no name)
+  emergencyContactRelationship  EmergencyContactRelationship? // Relationship enum (e.g. MIDWIFE, PARTNER)
+  
+  // Clinic Information
+  clinicName    String?
+  clinicAddress String?
+  clinicPhone   String?
+  
+  // Notification Preferences
+  notifyCarePriority Boolean @default(true)
+  notifyBpAlert      Boolean @default(true)
+  notifySymptomAlert Boolean @default(true)
+  notifyReminders    Boolean @default(true)
+  reminderTime       String? @default("09:00") // 24h format (HH:mm)
+  
+  createdAt         DateTime         @default(now())
+  updatedAt         DateTime         @updatedAt
+
+  // Relation to UserAuth
+  userAuth          UserAuth         @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@map("user_profile")
+}
+
+/**
+ * Blood Pressure Reading Entity
+ * 
+ * CLINICAL SAFETY CONSTRAINTS:
+ * - Manual entry only (no device integration)
+ * - Do NOT label readings as normal/abnormal
+ * - Do NOT store interpretations
+ * - Neutral data handling only
+ * 
+ * VALIDATION:
+ * - Systolic: 60-260 mmHg (physiologically possible range)
+ * - Diastolic: 40-160 mmHg (physiologically possible range)
+ * - Timestamp for temporal tracking
+ * 
+ * PURPOSE:
+ * - Store raw BP measurements
+ * - Used by care priority engine (Phase 3)
+ * - No diagnostic labels attached to data
+ */
+model BloodPressureReading {
+  id          String   @id @default(uuid())
+  userId      String
+  systolic    Int      // mmHg (60-260)
+  diastolic   Int      // mmHg (40-160)
+  recordedAt  DateTime @default(now())
+  createdAt   DateTime @default(now())
+
+  // Relation to UserAuth
+  userAuth    UserAuth @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@index([recordedAt])
+  @@map("blood_pressure_reading")
+}
+
+/**
+ * Symptom Type Enum
+ * 
+ * CLINICAL SAFETY:
+ * - Enumerated list of pregnancy hypertension warning signs
+ * - No free-text symptoms
+ * - No severity levels
+ * - Based on clinical guidelines for preeclampsia/eclampsia
+ */
+enum SymptomType {
+  HEADACHE                  // Severe or persistent headache
+  BLURRED_VISION            // Visual disturbances
+  SWELLING                  // Edema (face, hands, feet)
+  UPPER_ABDOMINAL_PAIN      // Right upper quadrant pain
+  REDUCED_URINE             // Decreased urine output
+  NAUSEA_VOMITING           // Persistent nausea/vomiting
+  SHORTNESS_OF_BREATH       // Difficulty breathing
+}
+
+/**
+ * Symptom Record Entity
+ * 
+ * CLINICAL SAFETY CONSTRAINTS:
+ * - Atomic recording (one symptom per record)
+ * - No severity levels
+ * - No numeric scoring
+ * - No interpretation or diagnosis
+ * 
+ * PURPOSE:
+ * - Track presence of warning symptoms
+ * - Used by care priority engine for escalation
+ * - Each symptom is a separate, timestamped record
+ */
+model SymptomRecord {
+  id          String      @id @default(uuid())
+  userId      String
+  symptomType SymptomType
+  recordedAt  DateTime    @default(now())
+  createdAt   DateTime    @default(now())
+
+  // Relation to UserAuth
+  userAuth    UserAuth    @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@index([recordedAt])
+  @@index([symptomType])
+  @@map("symptom_record")
+}
+
+/**
+ * Notification Type Enum
+ */
+enum NotificationType {
+  CARE_PRIORITY
+  BP_ALERT
+  SYMPTOM_ALERT
+  REMINDER
+}
+
+/**
+ * Notification Entity
+ * 
+ * PURPOSE:
+ * - Store history of alerts and notifications
+ * - Track read status
+ */
+model Notification {
+  id        String           @id @default(uuid())
+  userId    String
+  type      NotificationType
+  title     String
+  message   String
+  read      Boolean          @default(false)
+  createdAt DateTime         @default(now())
+  
+  userAuth  UserAuth         @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@index([createdAt])
+  @@map("notification")
+}

src/app.controller.ts

@@ -0,0 +1,30 @@
+import { Controller, Get } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
+
+@ApiTags('Health')
+@Controller()
+export class AppController {
+  @Get('health')
+  @ApiOperation({ summary: 'Check API health status' })
+  @ApiResponse({ status: 200, description: 'API is healthy' })
+  getHealth() {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      service: 'Maternal Health Support API',
+      clinical_safety_notice: 'CARE-SUPPORT TOOL - NOT A DIAGNOSTIC SYSTEM',
+    };
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'API Root' })
+  @ApiResponse({ status: 200, description: 'Welcome message' })
+  getHello() {
+    return {
+      message: 'Welcome to Maternal Health Support API',
+      version: '1.0.0',
+      docs: '/api/v1/docs',
+      health: '/api/v1/health',
+    };
+  }
+}

src/app.module.ts

@@ -0,0 +1,50 @@
+import { Module } from "@nestjs/common";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import { ThrottlerModule, ThrottlerGuard } from "@nestjs/throttler";
+import { APP_GUARD } from "@nestjs/core";
+import { ScheduleModule } from "@nestjs/schedule";
+import { DatabaseModule } from "./database/database.module";
+import { AuthModule } from "./auth/auth.module";
+import { UserProfileModule } from "./user-profile/user-profile.module";
+import { BloodPressureModule } from "./blood-pressure/blood-pressure.module";
+import { SymptomsModule } from "./symptoms/symptoms.module";
+import { CarePriorityModule } from "./care-priority/care-priority.module";
+import { NotificationsModule } from "./notifications/notifications.module";
+import { EducationModule } from "./education/education.module";
+import { ClinicFinderModule } from "./clinic-finder/clinic-finder.module";
+import { AppController } from "./app.controller";
+import { HealthController } from "./health.controller";
+
+@Module({
+  imports: [
+    // Configuration
+    ConfigModule.forRoot({
+      isGlobal: true,
+      envFilePath: ".env",
+    }),
+
+    // Scheduling
+    ScheduleModule.forRoot(),
+
+    // Database (Prisma) - Global module
+    DatabaseModule,
+
+    // Domain modules
+    AuthModule,
+    UserProfileModule,
+    BloodPressureModule,
+    SymptomsModule,
+    CarePriorityModule,
+    NotificationsModule,
+    EducationModule,
+    ClinicFinderModule,
+  ],
+  controllers: [AppController, HealthController],
+  providers: [
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },
+  ],
+})
+export class AppModule {}

src/auth/auth.controller.ts

@@ -0,0 +1,129 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Post,
+  Req,
+  UseGuards,
+} from "@nestjs/common";
+import { AuthService } from "./auth.service";
+import { RegisterDto } from "./dto/register.dto";
+import { LoginDto } from "./dto/login.dto";
+import { RefreshTokenDto } from "./dto/refresh-token.dto";
+import { AuthResponseDto } from "./dto/auth-response.dto";
+import { ForgotPasswordDto } from "./dto/forgot-password.dto";
+import { ResetPasswordDto } from "./dto/reset-password.dto";
+import { JwtAuthGuard } from "./guards/jwt-auth.guard";
+
+/**
+ * Authentication Controller
+ *
+ * ENDPOINTS:
+ * - POST /auth/register - Register new user
+ * - POST /auth/login - Login user
+ * - POST /auth/refresh - Refresh access token
+ * - POST /auth/forgot-password - Forgot password request
+ * - POST /auth/reset-password - Reset password with token
+ *
+ * CLINICAL SAFETY:
+ * - No health data collected
+ * - Minimal PII only
+ * - No credential logging
+ */
+
+@Controller("auth")
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  /**
+   * Register a new user
+   *
+   * @param registerDto - Email/phone and password
+   * @returns Access token, refresh token, and user ID
+   */
+  @Post("register")
+  @HttpCode(HttpStatus.CREATED)
+  async register(@Body() registerDto: RegisterDto): Promise<AuthResponseDto> {
+    return this.authService.register(registerDto);
+  }
+
+  /**
+   * Login user
+   *
+   * @param loginDto - Email/phone and password
+   * @returns Access token, refresh token, and user ID
+   */
+  @Post("login")
+  @HttpCode(HttpStatus.OK)
+  async login(@Body() loginDto: LoginDto): Promise<AuthResponseDto> {
+    return this.authService.login(loginDto);
+  }
+
+  /**
+   * Forgot password request
+   *
+   * @param forgotPasswordDto - Email or phone
+   */
+  @Post("forgot-password")
+  @HttpCode(HttpStatus.OK)
+  async forgotPassword(
+    @Body() forgotPasswordDto: ForgotPasswordDto
+  ): Promise<void> {
+    return this.authService.forgotPassword(forgotPasswordDto);
+  }
+
+  /**
+   * Reset password with token
+   *
+   * @param resetPasswordDto - Token and new password
+   */
+  @Post("reset-password")
+  @HttpCode(HttpStatus.OK)
+  async resetPassword(
+    @Body() resetPasswordDto: ResetPasswordDto
+  ): Promise<void> {
+    return this.authService.resetPassword(resetPasswordDto);
+  }
+
+  /**
+   * Refresh access token
+   *
+   * @param refreshTokenDto - Refresh token
+   * @returns New access token and refresh token
+   */
+  @Post("refresh")
+  @HttpCode(HttpStatus.OK)
+  async refresh(
+    @Body() refreshTokenDto: RefreshTokenDto
+  ): Promise<AuthResponseDto> {
+    return this.authService.refreshToken(refreshTokenDto.refreshToken);
+  }
+
+  /**
+   * Logout user
+   *
+   * SECURITY:
+   * - Requires valid access token
+   * - Clears stored refresh token so it cannot be reused
+   */
+  @Post("logout")
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async logout(@Req() req: any): Promise<void> {
+    await this.authService.logout(req.user.id);
+  }
+
+  /**
+   * Get current authenticated user
+   *
+   * @param req - Request with authenticated user
+   * @returns Current user details
+   */
+  @Post("me")
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getMe(@Req() req: any) {
+    return req.user;
+  }
+}

src/auth/auth.module.ts

@@ -0,0 +1,46 @@
+import { Module } from "@nestjs/common";
+import { JwtModule } from "@nestjs/jwt";
+import { PassportModule } from "@nestjs/passport";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import { AuthController } from "./auth.controller";
+import { AuthService } from "./auth.service";
+import { JwtStrategy } from "./strategies/jwt.strategy";
+import { NotificationsModule } from "../notifications/notifications.module";
+
+/**
+ * Authentication Module
+ *
+ * RESPONSIBILITIES:
+ * - User authentication (JWT-based)
+ * - Minimal PII storage
+ * - No health data in auth tables
+ * - No credential logging
+ *
+ * FEATURES:
+ * - Email OR phone login
+ * - Password hashing with bcrypt
+ * - JWT access tokens (short-lived)
+ * - Refresh token rotation
+ * - Secure authentication flow
+ */
+
+@Module({
+  imports: [
+    NotificationsModule,
+    PassportModule.register({ defaultStrategy: "jwt" }),
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        secret: configService.get("JWT_SECRET"),
+        signOptions: {
+          expiresIn: configService.get("JWT_EXPIRATION"),
+        },
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy],
+  exports: [AuthService, JwtStrategy, PassportModule],
+})
+export class AuthModule {}

src/auth/auth.service.ts

@@ -0,0 +1,343 @@
+import {
+  Injectable,
+  UnauthorizedException,
+  ConflictException,
+  Logger,
+  NotFoundException,
+} from "@nestjs/common";
+import { JwtService } from "@nestjs/jwt";
+import { ConfigService } from "@nestjs/config";
+import * as bcrypt from "bcrypt";
+import * as crypto from "crypto";
+import { PrismaService } from "../database/prisma.service";
+import { RegisterDto } from "./dto/register.dto";
+import { LoginDto } from "./dto/login.dto";
+import { AuthResponseDto } from "./dto/auth-response.dto";
+import { ForgotPasswordDto } from "./dto/forgot-password.dto";
+import { ResetPasswordDto } from "./dto/reset-password.dto";
+import { NotificationsService } from "../notifications/notifications.service";
+
+/**
+ * Authentication Service
+ *
+ * CLINICAL SAFETY PRINCIPLES:
+ * - Minimal PII storage
+ * - No health data in auth tables
+ * - No credential logging
+ * - Secure password hashing (bcrypt)
+ * - JWT-based stateless authentication
+ * - Refresh token rotation for security
+ */
+
+@Injectable()
+export class AuthService {
+  private readonly logger = new Logger(AuthService.name);
+  private readonly SALT_ROUNDS = 10;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly jwtService: JwtService,
+    private readonly configService: ConfigService,
+    private readonly notificationsService: NotificationsService,
+  ) {}
+
+  /**
+   * Forgot password request
+   */
+  async forgotPassword(forgotPasswordDto: ForgotPasswordDto): Promise<void> {
+    const { email, phone } = forgotPasswordDto;
+
+    if (!email && !phone) {
+      this.logger.warn("Forgot password attempt with no email or phone");
+      return;
+    }
+
+    // Find user — build conditions dynamically to avoid empty {} matching all rows
+    const conditions: any[] = [];
+    if (email) conditions.push({ email });
+    if (phone) conditions.push({ phone });
+
+    const user = await this.prisma.userAuth.findFirst({
+      where: conditions.length === 1 ? conditions[0] : { OR: conditions },
+    });
+
+    if (!user) {
+      // Don't reveal if user exists for security
+      this.logger.warn(
+        `Forgot password attempt for non-existent user: ${email || phone}`,
+      );
+      return;
+    }
+
+    // Generate token (valid for 1 hour)
+    const token = crypto.randomBytes(32).toString("hex");
+    const expires = new Date();
+    expires.setHours(expires.getHours() + 1);
+
+    // Save token
+    await this.prisma.userAuth.update({
+      where: { id: user.id },
+      data: {
+        resetPasswordToken: token,
+        resetPasswordExpires: expires,
+      },
+    });
+
+    // Send reset message (via notification service)
+    await this.notificationsService.sendResetPasswordNotification(
+      user.id,
+      token,
+    );
+
+    this.logger.log(`Password reset token generated for user: ${user.id}`);
+  }
+
+  /**
+   * Reset password with token
+   */
+  async resetPassword(resetPasswordDto: ResetPasswordDto): Promise<void> {
+    const { token, newPassword } = resetPasswordDto;
+
+    // Find user with valid token
+    const user = await this.prisma.userAuth.findFirst({
+      where: {
+        resetPasswordToken: token,
+        resetPasswordExpires: { gt: new Date() },
+      },
+    });
+
+    if (!user) {
+      throw new UnauthorizedException("Invalid or expired reset token");
+    }
+
+    // Hash new password
+    const passwordHash = await bcrypt.hash(newPassword, this.SALT_ROUNDS);
+
+    // Update user
+    await this.prisma.userAuth.update({
+      where: { id: user.id },
+      data: {
+        passwordHash,
+        resetPasswordToken: null,
+        resetPasswordExpires: null,
+        refreshToken: null, // Force logout from all devices
+      },
+    });
+
+    this.logger.log(`Password reset successful for user: ${user.id}`);
+  }
+
+  /**
+   * Register a new user
+   *
+   * CONSTRAINTS:
+   * - Email OR phone required (not both)
+   * - Password must be at least 8 characters
+   * - No duplicate email/phone
+   */
+  async register(registerDto: RegisterDto): Promise<AuthResponseDto> {
+    this.logger.log(
+      `Registration attempt for: ${registerDto.email || registerDto.phone}`,
+    );
+    const { email, phone, password } = registerDto;
+
+    // Validate that at least one identifier is provided
+    if (!email && !phone) {
+      throw new ConflictException("Either email or phone must be provided");
+    }
+
+    // Check for existing user — build conditions dynamically
+    const conditions: any[] = [];
+    if (email) conditions.push({ email });
+    if (phone) conditions.push({ phone });
+
+    const existingUser = await this.prisma.userAuth.findFirst({
+      where: conditions.length === 1 ? conditions[0] : { OR: conditions },
+    });
+
+    if (existingUser) {
+      throw new ConflictException(
+        "User with this email or phone already exists",
+      );
+    }
+
+    // Hash password (NEVER log the password)
+    const passwordHash = await bcrypt.hash(password, this.SALT_ROUNDS);
+
+    // Create user
+    try {
+      const user = await this.prisma.userAuth.create({
+        data: {
+          email,
+          phone,
+          passwordHash,
+        },
+      });
+      this.logger.log(`New user registered: ${user.id}`);
+      return this.generateTokens(user.id);
+    } catch (error: any) {
+      this.logger.error(
+        `Database error during registration: ${error.message}`,
+        error.stack,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Login user
+   *
+   * CONSTRAINTS:
+   * - Email OR phone required
+   * - Password verification
+   * - No credential logging
+   */
+  async login(loginDto: LoginDto): Promise<AuthResponseDto> {
+    const { email, phone, password } = loginDto;
+
+    // Validate that at least one identifier is provided
+    if (!email && !phone) {
+      throw new UnauthorizedException("Either email or phone must be provided");
+    }
+
+    // Find user — build conditions dynamically
+    const loginConditions: any[] = [];
+    if (email) loginConditions.push({ email });
+    if (phone) loginConditions.push({ phone });
+
+    const user = await this.prisma.userAuth.findFirst({
+      where:
+        loginConditions.length === 1
+          ? loginConditions[0]
+          : { OR: loginConditions },
+    });
+
+    if (!user) {
+      // Generic error to prevent user enumeration
+      throw new UnauthorizedException("Invalid credentials");
+    }
+
+    // Verify password (NEVER log the password)
+    const isPasswordValid = await bcrypt.compare(password, user.passwordHash);
+
+    if (!isPasswordValid) {
+      throw new UnauthorizedException("Invalid credentials");
+    }
+
+    // Check if user is active
+    if (!user.isActive) {
+      throw new UnauthorizedException("Account is inactive");
+    }
+
+    this.logger.log(`User logged in: ${user.id}`);
+
+    // Generate tokens
+    return this.generateTokens(user.id);
+  }
+
+  /**
+   * Refresh access token
+   */
+  async refreshToken(refreshToken: string): Promise<AuthResponseDto> {
+    try {
+      // Verify refresh token
+      const payload = this.jwtService.verify(refreshToken, {
+        secret: this.configService.get("JWT_REFRESH_SECRET"),
+      });
+
+      // Find user
+      const user = await this.prisma.userAuth.findUnique({
+        where: { id: payload.sub },
+      });
+
+      if (!user || !user.isActive) {
+        throw new UnauthorizedException("Invalid refresh token");
+      }
+
+      // Verify stored refresh token matches
+      if (user.refreshToken !== refreshToken) {
+        throw new UnauthorizedException("Invalid refresh token");
+      }
+
+      // Generate new tokens
+      return this.generateTokens(user.id);
+    } catch (error) {
+      throw new UnauthorizedException("Invalid refresh token");
+    }
+  }
+
+  /**
+   * Logout user by invalidating stored refresh token
+   *
+   * SECURITY:
+   * - Clears refresh token from database so it can no longer be used
+   */
+  async logout(userId: string): Promise<void> {
+    await this.prisma.userAuth.update({
+      where: { id: userId },
+      data: {
+        refreshToken: null,
+        pushToken: null, // Clear push token on logout for security
+      },
+    });
+
+    this.logger.log(`User logged out: ${userId}`);
+  }
+
+  /**
+   * Generate JWT access and refresh tokens
+   *
+   * SECURITY:
+   * - Access token: short-lived (1 hour)
+   * - Refresh token: longer-lived (7 days)
+   * - Refresh token stored in database for rotation
+   */
+  private async generateTokens(userId: string): Promise<AuthResponseDto> {
+    const payload = { sub: userId };
+
+    // Generate access token
+    const accessToken = this.jwtService.sign(payload, {
+      secret: this.configService.get("JWT_SECRET"),
+      expiresIn: this.configService.get("JWT_EXPIRATION"),
+    });
+
+    // Generate refresh token
+    const refreshToken = this.jwtService.sign(payload, {
+      secret: this.configService.get("JWT_REFRESH_SECRET"),
+      expiresIn: this.configService.get("JWT_REFRESH_EXPIRATION"),
+    });
+
+    // Store refresh token in database
+    await this.prisma.userAuth.update({
+      where: { id: userId },
+      data: { refreshToken },
+    });
+
+    return {
+      accessToken,
+      refreshToken,
+      userId,
+    };
+  }
+
+  /**
+   * Validate user by ID (used by JWT strategy)
+   */
+  async validateUser(userId: string) {
+    const user = await this.prisma.userAuth.findUnique({
+      where: { id: userId },
+      select: {
+        id: true,
+        email: true,
+        phone: true,
+        isActive: true,
+      },
+    });
+
+    if (!user || !user.isActive) {
+      return null;
+    }
+
+    return user;
+  }
+}

src/auth/dto/auth-response.dto.ts

@@ -0,0 +1,10 @@
+/**
+ * Auth Response DTO
+ *
+ * Returned after successful login or registration
+ */
+export class AuthResponseDto {
+  accessToken!: string;
+  refreshToken!: string;
+  userId!: string;
+}

src/auth/dto/forgot-password.dto.ts

@@ -0,0 +1,17 @@
+import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+/**
+ * Forgot Password DTO
+ * 
+ * Supports both email and phone for reset
+ */
+export class ForgotPasswordDto {
+  @IsEmail()
+  @IsOptional()
+  email?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  phone?: string;
+}

src/auth/dto/login.dto.ts

@@ -0,0 +1,23 @@
+import { IsEmail, IsOptional, IsString, ValidateIf } from "class-validator";
+
+/**
+ * Login DTO
+ *
+ * CLINICAL SAFETY:
+ * - Email OR phone for login
+ * - No credential logging
+ */
+export class LoginDto {
+  @IsOptional()
+  @IsEmail()
+  @ValidateIf((o) => !o.phone)
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  @ValidateIf((o) => !o.email)
+  phone?: string;
+
+  @IsString()
+  password!: string;
+}

src/auth/dto/refresh-token.dto.ts

@@ -0,0 +1,9 @@
+import { IsString } from "class-validator";
+
+/**
+ * Refresh Token DTO
+ */
+export class RefreshTokenDto {
+  @IsString()
+  refreshToken!: string;
+}

src/auth/dto/register.dto.ts

@@ -0,0 +1,31 @@
+import {
+  IsEmail,
+  IsOptional,
+  IsString,
+  MinLength,
+  ValidateIf,
+} from "class-validator";
+
+/**
+ * Register DTO
+ *
+ * CLINICAL SAFETY:
+ * - Email OR phone required (not both)
+ * - No health data collected during registration
+ * - Minimal PII only
+ */
+export class RegisterDto {
+  @IsOptional()
+  @IsEmail()
+  @ValidateIf((o) => !o.phone) // Email required if no phone
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  @ValidateIf((o) => !o.email) // Phone required if no email
+  phone?: string;
+
+  @IsString()
+  @MinLength(8, { message: "Password must be at least 8 characters long" })
+  password!: string;
+}

src/auth/dto/reset-password.dto.ts

@@ -0,0 +1,17 @@
+import { IsNotEmpty, IsString, MinLength } from 'class-validator';
+
+/**
+ * Reset Password DTO
+ * 
+ * Used with a reset token to set a new password
+ */
+export class ResetPasswordDto {
+  @IsString()
+  @IsNotEmpty()
+  token!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(8, { message: 'Password must be at least 8 characters' })
+  newPassword!: string;
+}

src/auth/guards/jwt-auth.guard.ts

@@ -0,0 +1,14 @@
+import { Injectable } from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+
+/**
+ * JWT Auth Guard
+ *
+ * Use this guard to protect routes that require authentication
+ *
+ * Usage:
+ * @UseGuards(JwtAuthGuard)
+ */
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard("jwt") {}

src/auth/strategies/jwt.strategy.ts

@@ -0,0 +1,39 @@
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import { ExtractJwt, Strategy } from "passport-jwt";
+import { ConfigService } from "@nestjs/config";
+import { AuthService } from "../auth.service";
+
+/**
+ * JWT Strategy
+ *
+ * Validates JWT tokens and attaches user to request
+ */
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly authService: AuthService
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>("JWT_SECRET") || "fallback_secret",
+    });
+  }
+
+  /**
+   * Validate JWT payload
+   * Called automatically by Passport after token verification
+   */
+  async validate(payload: any) {
+    const user = await this.authService.validateUser(payload.sub);
+
+    if (!user) {
+      throw new UnauthorizedException();
+    }
+
+    return user;
+  }
+}

src/blood-pressure/blood-pressure.controller.ts

@@ -0,0 +1,92 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Delete,
+  Body,
+  Param,
+  Query,
+  UseGuards,
+  Request,
+  HttpCode,
+  HttpStatus,
+  ParseIntPipe,
+  Inject,
+  forwardRef,
+} from "@nestjs/common";
+import { BloodPressureService } from "./blood-pressure.service";
+import { CreateBloodPressureDto } from "./dto/create-blood-pressure.dto";
+import { JwtAuthGuard } from "../auth/guards/jwt-auth.guard";
+import { HealthAssessmentService } from "../care-priority/health-assessment.service";
+
+@Controller("blood-pressure")
+@UseGuards(JwtAuthGuard)
+export class BloodPressureController {
+  constructor(
+    private readonly bloodPressureService: BloodPressureService,
+    @Inject(forwardRef(() => HealthAssessmentService))
+    private readonly healthAssessmentService: HealthAssessmentService
+  ) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  async create(
+    @Request() req: any,
+    @Body() createBloodPressureDto: CreateBloodPressureDto
+  ) {
+    const userId = req.user.id;
+    const reading = await this.bloodPressureService.create(
+      userId,
+      createBloodPressureDto
+    );
+
+    // Trigger health assessment and notifications (don't await to avoid blocking response)
+    this.healthAssessmentService.assessAndNotify(userId);
+
+    return reading;
+  }
+
+  /**
+   * Get all BP readings for authenticated user
+   *
+   * @param req - Request with authenticated user
+   * @param limit - Optional limit (default: 50)
+   * @returns Array of BP readings
+   */
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  async getReadings(
+    @Request() req: any,
+    @Query("limit", new ParseIntPipe({ optional: true })) limit?: number
+  ) {
+    const userId = req.user.id;
+    return this.bloodPressureService.findByUserId(userId, limit);
+  }
+
+  /**
+   * Get latest BP reading
+   *
+   * @param req - Request with authenticated user
+   * @returns Latest BP reading or null
+   */
+  @Get("latest")
+  @HttpCode(HttpStatus.OK)
+  async getLatest(@Request() req: any) {
+    const userId = req.user.id;
+    return this.bloodPressureService.getLatestReading(userId);
+  }
+
+  /**
+   * Delete a BP reading
+   *
+   * @param req - Request with authenticated user
+   * @param id - Reading ID
+   * @returns Success message
+   */
+  @Delete(":id")
+  @HttpCode(HttpStatus.OK)
+  async delete(@Request() req: any, @Param("id") id: string) {
+    const userId = req.user.id;
+    return this.bloodPressureService.delete(id, userId);
+  }
+}

src/blood-pressure/blood-pressure.module.ts

@@ -0,0 +1,27 @@
+import { Module, forwardRef } from "@nestjs/common";
+import { BloodPressureController } from "./blood-pressure.controller";
+import { BloodPressureService } from "./blood-pressure.service";
+import { CarePriorityModule } from "../care-priority/care-priority.module";
+
+/**
+ * Blood Pressure Module
+ *
+ * RESPONSIBILITIES:
+ * - Store BP readings (systolic/diastolic)
+ * - Manual entry only
+ * - Timestamp tracking
+ *
+ * CLINICAL SAFETY CONSTRAINTS:
+ * - Do NOT label readings as normal/abnormal
+ * - Do NOT store interpretations
+ * - Neutral data handling only
+ * - Raw measurements for care priority engine
+ */
+
+@Module({
+  imports: [forwardRef(() => CarePriorityModule)],
+  controllers: [BloodPressureController],
+  providers: [BloodPressureService],
+  exports: [BloodPressureService],
+})
+export class BloodPressureModule {}

src/blood-pressure/blood-pressure.service.ts

@@ -0,0 +1,151 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { PrismaService } from "../database/prisma.service";
+import { CreateBloodPressureDto } from "./dto/create-blood-pressure.dto";
+
+/**
+ * Blood Pressure Service
+ *
+ * CLINICAL SAFETY PRINCIPLES:
+ * - Manual entry only (no device integration)
+ * - Do NOT label readings as normal/abnormal
+ * - Do NOT store interpretations
+ * - Neutral data handling only
+ *
+ * RESPONSIBILITIES:
+ * - Store BP readings with validation
+ * - Retrieve readings for user
+ * - Provide latest reading for care priority engine
+ * - Query readings by date range
+ */
+
+@Injectable()
+export class BloodPressureService {
+  private readonly logger = new Logger(BloodPressureService.name);
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  /**
+   * Create a new blood pressure reading
+   *
+   * CONSTRAINTS:
+   * - Systolic: 60-260 mmHg
+   * - Diastolic: 40-160 mmHg
+   * - No interpretation stored
+   */
+  async create(userId: string, createBloodPressureDto: CreateBloodPressureDto) {
+    const { systolic, diastolic, recordedAt } = createBloodPressureDto;
+
+    const reading = await this.prisma.bloodPressureReading.create({
+      data: {
+        userId,
+        systolic,
+        diastolic,
+        recordedAt: recordedAt ? new Date(recordedAt) : new Date(),
+      },
+    });
+
+    this.logger.log(
+      `BP reading created for user: ${userId} (${systolic}/${diastolic})`
+    );
+
+    return reading;
+  }
+
+  /**
+   * Get all BP readings for a user
+   *
+   * @param userId - User ID
+   * @param limit - Optional limit (default: 50)
+   * @returns Array of BP readings, newest first
+   */
+  async findByUserId(userId: string, limit: number = 50) {
+    const readings = await this.prisma.bloodPressureReading.findMany({
+      where: { userId },
+      orderBy: { recordedAt: "desc" },
+      take: limit,
+    });
+
+    return readings;
+  }
+
+  /**
+   * Get latest BP reading for a user
+   *
+   * Used by care priority engine
+   */
+  async getLatestReading(userId: string) {
+    const reading = await this.prisma.bloodPressureReading.findFirst({
+      where: { userId },
+      orderBy: { recordedAt: "desc" },
+    });
+
+    return reading;
+  }
+
+  /**
+   * Get BP readings within a date range
+   *
+   * @param userId - User ID
+   * @param startDate - Start date
+   * @param endDate - End date
+   * @returns Array of BP readings in range
+   */
+  async getReadingsInRange(userId: string, startDate: Date, endDate: Date) {
+    const readings = await this.prisma.bloodPressureReading.findMany({
+      where: {
+        userId,
+        recordedAt: {
+          gte: startDate,
+          lte: endDate,
+        },
+      },
+      orderBy: { recordedAt: "desc" },
+    });
+
+    return readings;
+  }
+
+  /**
+   * Get readings from last N hours
+   *
+   * Used by care priority engine to check recent trends
+   */
+  async getRecentReadings(userId: string, hours: number = 48) {
+    const cutoffDate = new Date();
+    cutoffDate.setHours(cutoffDate.getHours() - hours);
+
+    const readings = await this.prisma.bloodPressureReading.findMany({
+      where: {
+        userId,
+        recordedAt: {
+          gte: cutoffDate,
+        },
+      },
+      orderBy: { recordedAt: "desc" },
+    });
+
+    return readings;
+  }
+
+  /**
+   * Delete a BP reading
+   */
+  async delete(id: string, userId: string) {
+    // Ensure user owns the reading
+    const reading = await this.prisma.bloodPressureReading.findFirst({
+      where: { id, userId },
+    });
+
+    if (!reading) {
+      throw new Error("Reading not found or unauthorized");
+    }
+
+    await this.prisma.bloodPressureReading.delete({
+      where: { id },
+    });
+
+    this.logger.log(`BP reading deleted: ${id}`);
+
+    return { message: "Reading deleted successfully" };
+  }
+}

src/blood-pressure/dto/create-blood-pressure.dto.ts

@@ -0,0 +1,30 @@
+import { IsInt, Min, Max, IsOptional, IsDateString } from "class-validator";
+
+/**
+ * Create Blood Pressure Reading DTO
+ *
+ * VALIDATION RULES:
+ * - Systolic: 60-260 mmHg (physiologically possible range)
+ * - Diastolic: 40-160 mmHg (physiologically possible range)
+ * - Optional recordedAt (defaults to now)
+ *
+ * CLINICAL SAFETY:
+ * - No interpretation or labeling
+ * - Neutral data collection only
+ * - Manual entry only
+ */
+export class CreateBloodPressureDto {
+  @IsInt()
+  @Min(60, { message: "Systolic must be at least 60 mmHg" })
+  @Max(260, { message: "Systolic must not exceed 260 mmHg" })
+  systolic!: number;
+
+  @IsInt()
+  @Min(40, { message: "Diastolic must be at least 40 mmHg" })
+  @Max(160, { message: "Diastolic must not exceed 160 mmHg" })
+  diastolic!: number;
+
+  @IsOptional()
+  @IsDateString()
+  recordedAt?: string;
+}

src/care-priority/care-priority.controller.ts

@@ -0,0 +1,71 @@
+import {
+  Controller,
+  Get,
+  UseGuards,
+  Request,
+  HttpCode,
+  HttpStatus,
+} from "@nestjs/common";
+import { CarePriorityService } from "./care-priority.service";
+import { JwtAuthGuard } from "../auth/guards/jwt-auth.guard";
+
+/**
+ * Care Priority Controller
+ *
+ * ENDPOINT:
+ * - GET /care-priority - Get current care priority (authenticated, read-only)
+ *
+ * CLINICAL SAFETY:
+ * - Read-only endpoint (no POST/PUT/DELETE)
+ * - Returns priority level and safe next step message
+ * - Non-diagnostic language only
+ * - No explanation of medical reasoning
+ * - Template-based messaging
+ *
+ * RESPONSE FORMAT:
+ * {
+ *   priority: 'ROUTINE' | 'INCREASED_MONITORING' | 'URGENT_REVIEW' | 'EMERGENCY',
+ *   message: 'Safe next step message',
+ *   reasons: ['Factor 1', 'Factor 2'],
+ *   timestamp: '2024-01-01T00:00:00.000Z'
+ * }
+ */
+
+@Controller("care-priority")
+@UseGuards(JwtAuthGuard)
+export class CarePriorityController {
+  constructor(private readonly carePriorityService: CarePriorityService) {}
+
+  /**
+   * Get current care priority for authenticated user
+   *
+   * CONSTRAINTS:
+   * - Read-only operation
+   * - Calculates priority based on latest data
+   * - Returns predefined safe message
+   * - No diagnostic information
+   *
+   * @param req - Request with authenticated user
+   * @returns Care priority result with safe message
+   */
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  async getCarePriority(@Request() req: any) {
+    const userId = req.user.id;
+
+    // Calculate care priority
+    const result = await this.carePriorityService.calculateCarePriority(userId);
+
+    // Get safe next step message
+    const message = this.carePriorityService.getSafeNextStepMessage(
+      result.priority
+    );
+
+    return {
+      priority: result.priority,
+      message,
+      reasons: result.reasons,
+      timestamp: result.timestamp,
+    };
+  }
+}

src/care-priority/care-priority.module.ts

@@ -0,0 +1,21 @@
+import { Module, forwardRef } from "@nestjs/common";
+import { CarePriorityService } from "./care-priority.service";
+import { CarePriorityController } from "./care-priority.controller";
+import { BloodPressureModule } from "../blood-pressure/blood-pressure.module";
+import { SymptomsModule } from "../symptoms/symptoms.module";
+import { UserProfileModule } from "../user-profile/user-profile.module";
+import { NotificationsModule } from "../notifications/notifications.module";
+import { HealthAssessmentService } from "./health-assessment.service";
+
+@Module({
+  imports: [
+    forwardRef(() => BloodPressureModule),
+    forwardRef(() => SymptomsModule),
+    UserProfileModule,
+    NotificationsModule,
+  ],
+  controllers: [CarePriorityController],
+  providers: [CarePriorityService, HealthAssessmentService],
+  exports: [CarePriorityService, HealthAssessmentService],
+})
+export class CarePriorityModule {}

src/care-priority/care-priority.service.ts

@@ -0,0 +1,298 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { BloodPressureService } from "../blood-pressure/blood-pressure.service";
+import { SymptomsService } from "../symptoms/symptoms.service";
+import { UserProfileService } from "../user-profile/user-profile.service";
+import { CarePriority, CarePriorityResult } from "./types/care-priority.types";
+import { KnownCondition, SymptomType } from "@prisma/client";
+
+/**
+ * Care Priority Engine Service
+ *
+ * ⚠️ MOST CRITICAL MODULE - CLINICAL SAFETY ⚠️
+ *
+ * PRINCIPLES:
+ * - Deterministic, rule-based logic (NO AI/ML)
+ * - NO diagnosis
+ * - NO medical advice
+ * - NO risk scoring or probability calculations
+ * - Default to HIGHER priority when uncertain
+ * - Based on clinical guidelines for hypertensive disorders in pregnancy
+ *
+ * RULES SOURCE:
+ * - ACOG (American College of Obstetricians and Gynecologists) guidelines
+ * - Preeclampsia Foundation recommendations
+ * - NHS (UK) hypertension in pregnancy guidelines
+ *
+ * PURPOSE:
+ * - Provide care escalation recommendations
+ * - Guide users to seek appropriate level of care
+ * - NOT to replace clinical judgment
+ */
+
+@Injectable()
+export class CarePriorityService {
+  private readonly logger = new Logger(CarePriorityService.name);
+
+  constructor(
+    private readonly bloodPressureService: BloodPressureService,
+    private readonly symptomsService: SymptomsService,
+    private readonly userProfileService: UserProfileService
+  ) {}
+
+  /**
+   * Calculate care priority for a user
+   *
+   * ALGORITHM:
+   * 1. Check for EMERGENCY conditions (immediate medical attention)
+   * 2. Check for URGENT_REVIEW conditions (contact provider within 24h)
+   * 3. Check for INCREASED_MONITORING conditions (more frequent monitoring)
+   * 4. Default to ROUTINE if no concerning factors
+   *
+   * CONSERVATIVE APPROACH:
+   * - If multiple factors present, use highest priority
+   * - If uncertain, escalate to higher priority
+   * - Better to over-escalate than under-escalate
+   */
+  async calculateCarePriority(userId: string): Promise<CarePriorityResult> {
+    const reasons: string[] = [];
+    let priority: CarePriority = CarePriority.ROUTINE;
+
+    try {
+      // Get user data
+      const profile = await this.userProfileService.findByUserId(userId);
+      const latestBP = await this.bloodPressureService.getLatestReading(userId);
+      const recentBPs = await this.bloodPressureService.getRecentReadings(
+        userId,
+        48
+      );
+      const recentSymptoms = await this.symptomsService.getRecentSymptoms(
+        userId,
+        72
+      );
+
+      // ========================================
+      // EMERGENCY CHECKS
+      // ========================================
+
+      // EMERGENCY: Severe hypertension (BP ≥160/110)
+      if (latestBP && (latestBP.systolic >= 160 || latestBP.diastolic >= 110)) {
+        priority = CarePriority.EMERGENCY;
+        reasons.push("Blood pressure reading indicates severe hypertension");
+        this.logger.warn(
+          `EMERGENCY priority for user ${userId}: BP ${latestBP.systolic}/${latestBP.diastolic}`
+        );
+      }
+
+      // EMERGENCY: Dangerous symptom combinations
+      const symptomTypes = new Set(
+        recentSymptoms.map((s: any) => s.symptomType)
+      );
+
+      // Severe preeclampsia warning signs
+      if (
+        symptomTypes.has(SymptomType.HEADACHE) &&
+        symptomTypes.has(SymptomType.BLURRED_VISION)
+      ) {
+        priority = CarePriority.EMERGENCY;
+        reasons.push("Combination of severe headache and vision changes");
+        this.logger.warn(
+          `EMERGENCY priority for user ${userId}: Headache + Vision changes`
+        );
+      }
+
+      if (
+        symptomTypes.has(SymptomType.UPPER_ABDOMINAL_PAIN) &&
+        symptomTypes.has(SymptomType.NAUSEA_VOMITING)
+      ) {
+        priority = CarePriority.EMERGENCY;
+        reasons.push("Upper abdominal pain with nausea/vomiting");
+        this.logger.warn(
+          `EMERGENCY priority for user ${userId}: Abdominal pain + Nausea`
+        );
+      }
+
+      if (symptomTypes.has(SymptomType.SHORTNESS_OF_BREATH)) {
+        priority = CarePriority.EMERGENCY;
+        reasons.push("Difficulty breathing reported");
+        this.logger.warn(
+          `EMERGENCY priority for user ${userId}: Shortness of breath`
+        );
+      }
+
+      // If already EMERGENCY, return immediately
+      if (priority === CarePriority.EMERGENCY) {
+        return {
+          priority,
+          reasons,
+          timestamp: new Date(),
+        };
+      }
+
+      // ========================================
+      // URGENT_REVIEW CHECKS
+      // ========================================
+
+      // URGENT: Confirmed hypertension (BP ≥140/90 on two occasions)
+      if (recentBPs.length >= 2) {
+        const elevatedReadings = recentBPs.filter(
+          (bp: any) => bp.systolic >= 140 || bp.diastolic >= 90
+        );
+
+        if (elevatedReadings.length >= 2) {
+          priority = CarePriority.URGENT_REVIEW;
+          reasons.push("Multiple elevated blood pressure readings");
+        }
+      }
+
+      // URGENT: High-risk conditions + elevated BP
+      const highRiskConditions = [
+        KnownCondition.CHRONIC_HYPERTENSION,
+        KnownCondition.PREECLAMPSIA_HISTORY,
+        KnownCondition.KIDNEY_DISEASE,
+      ];
+
+      const hasHighRiskCondition = profile.knownConditions.some(
+        (condition: any) => highRiskConditions.includes(condition)
+      );
+
+      if (
+        hasHighRiskCondition &&
+        latestBP &&
+        (latestBP.systolic >= 130 || latestBP.diastolic >= 85)
+      ) {
+        priority = CarePriority.URGENT_REVIEW;
+        reasons.push("High-risk condition with elevated blood pressure");
+      }
+
+      // URGENT: Any severe symptoms individually
+      if (
+        symptomTypes.has(SymptomType.HEADACHE) ||
+        symptomTypes.has(SymptomType.BLURRED_VISION) ||
+        symptomTypes.has(SymptomType.UPPER_ABDOMINAL_PAIN)
+      ) {
+        if (priority !== CarePriority.URGENT_REVIEW) {
+          priority = CarePriority.URGENT_REVIEW;
+        }
+        reasons.push("Warning symptoms present");
+      }
+
+      // URGENT: Reduced urine output
+      if (symptomTypes.has(SymptomType.REDUCED_URINE)) {
+        priority = CarePriority.URGENT_REVIEW;
+        reasons.push("Reduced urine output reported");
+      }
+
+      // If URGENT_REVIEW, return
+      if (priority === CarePriority.URGENT_REVIEW) {
+        return {
+          priority,
+          reasons,
+          timestamp: new Date(),
+        };
+      }
+
+      // ========================================
+      // INCREASED_MONITORING CHECKS
+      // ========================================
+
+      // INCREASED: Borderline BP (130-159 / 85-109)
+      if (
+        latestBP &&
+        (latestBP.systolic >= 130 || latestBP.diastolic >= 85)
+      ) {
+        priority = CarePriority.INCREASED_MONITORING;
+        reasons.push("Blood pressure reading is above normal range");
+      }
+
+      // INCREASED: High-risk conditions present
+      if (hasHighRiskCondition) {
+        priority = CarePriority.INCREASED_MONITORING;
+        reasons.push("High-risk pregnancy condition present");
+      }
+
+      // INCREASED: Advanced maternal age (35+)
+      if (profile.ageRange === "AGE_35_PLUS") {
+        if (priority !== CarePriority.INCREASED_MONITORING) {
+          priority = CarePriority.INCREASED_MONITORING;
+        }
+        reasons.push("Advanced maternal age");
+      }
+
+      // INCREASED: Multiple pregnancy
+      if (profile.knownConditions.includes(KnownCondition.MULTIPLE_PREGNANCY)) {
+        priority = CarePriority.INCREASED_MONITORING;
+        reasons.push("Multiple pregnancy");
+      }
+
+      // INCREASED: Any symptoms present (even mild)
+      if (recentSymptoms.length > 0) {
+        if (priority !== CarePriority.INCREASED_MONITORING) {
+          priority = CarePriority.INCREASED_MONITORING;
+        }
+        reasons.push("Symptoms reported");
+      }
+
+      // If INCREASED_MONITORING, return
+      if (priority === CarePriority.INCREASED_MONITORING) {
+        return {
+          priority,
+          reasons,
+          timestamp: new Date(),
+        };
+      }
+
+      // ========================================
+      // ROUTINE (Default)
+      // ========================================
+
+      reasons.push("No concerning factors identified");
+
+      return {
+        priority: CarePriority.ROUTINE,
+        reasons,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      // SAFETY: If calculation fails, default to INCREASED_MONITORING
+      this.logger.error(
+        `Error calculating care priority for user ${userId}:`,
+        error
+      );
+
+      return {
+        priority: CarePriority.INCREASED_MONITORING,
+        reasons: [
+          "Unable to complete assessment - please contact your healthcare provider",
+        ],
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  /**
+   * Get safe next step message based on priority
+   *
+   * CONSTRAINTS:
+   * - Predefined templates only
+   * - No dynamic medical text
+   * - No diagnostic language
+   * - No fear-based messaging
+   */
+  getSafeNextStepMessage(priority: CarePriority): string {
+    const messages = {
+      [CarePriority.EMERGENCY]:
+        "Seek immediate medical attention. Call emergency services or go to the nearest emergency room.",
+
+      [CarePriority.URGENT_REVIEW]:
+        "Contact your healthcare provider within the next 24 hours to discuss your readings.",
+
+      [CarePriority.INCREASED_MONITORING]:
+        "Continue monitoring your blood pressure regularly and discuss with your healthcare provider at your next appointment.",
+
+      [CarePriority.ROUTINE]:
+        "Continue routine prenatal care and monitoring as recommended by your healthcare provider.",
+    };
+
+    return messages[priority];
+  }
+}

src/care-priority/health-assessment.service.ts

@@ -0,0 +1,104 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { CarePriorityService } from "./care-priority.service";
+import { NotificationsService } from "../notifications/notifications.service";
+import { BloodPressureService } from "../blood-pressure/blood-pressure.service";
+import { SymptomsService } from "../symptoms/symptoms.service";
+import { CarePriority } from "./types/care-priority.types";
+import { SymptomType } from "@prisma/client";
+
+@Injectable()
+export class HealthAssessmentService {
+  private readonly logger = new Logger(HealthAssessmentService.name);
+
+  constructor(
+    private readonly carePriorityService: CarePriorityService,
+    private readonly notificationsService: NotificationsService,
+    private readonly bloodPressureService: BloodPressureService,
+    private readonly symptomsService: SymptomsService
+  ) {}
+
+  /**
+   * Assess user health after a new BP reading or symptom is recorded
+   * and trigger appropriate notifications.
+   */
+  async assessAndNotify(userId: string): Promise<void> {
+    try {
+      this.logger.log(`Starting health assessment for user: ${userId}`);
+
+      // 1. Calculate current care priority
+      const assessment = await this.carePriorityService.calculateCarePriority(
+        userId
+      );
+      const { priority } = assessment;
+
+      // 2. Get latest data for specific alerts
+      const latestBP = await this.bloodPressureService.getLatestReading(userId);
+      const recentSymptoms = await this.symptomsService.getRecentSymptoms(
+        userId,
+        24
+      );
+      const symptomTypes = new Set(
+        recentSymptoms.map((s: any) => s.symptomType)
+      );
+
+      // 3. Trigger specific BP alerts if needed
+      if (latestBP) {
+        if (latestBP.systolic >= 160 || latestBP.diastolic >= 110) {
+          await this.notificationsService.sendSevereBPAlert(
+            userId,
+            latestBP.systolic,
+            latestBP.diastolic
+          );
+        } else if (latestBP.systolic >= 140 || latestBP.diastolic >= 90) {
+          await this.notificationsService.sendElevatedBPNotification(
+            userId,
+            latestBP.systolic,
+            latestBP.diastolic
+          );
+        }
+      }
+
+      // 4. Trigger symptom alerts if dangerous symptoms are present
+      const dangerousSymptoms = [
+        SymptomType.HEADACHE,
+        SymptomType.BLURRED_VISION,
+        SymptomType.UPPER_ABDOMINAL_PAIN,
+        SymptomType.SHORTNESS_OF_BREATH,
+      ];
+
+      const hasDangerousSymptom = Array.from(symptomTypes).some((type) =>
+        dangerousSymptoms.includes(type)
+      );
+
+      if (hasDangerousSymptom) {
+        const activeDangerous = Array.from(symptomTypes).filter((type) =>
+          dangerousSymptoms.includes(type)
+        );
+        await this.notificationsService.sendDangerousSymptomAlert(
+          userId,
+          activeDangerous.map((s) => s.toString())
+        );
+      } else if (symptomTypes.size > 0) {
+        await this.notificationsService.sendWarningSymptomNotification(
+          userId,
+          Array.from(symptomTypes)[0].toString()
+        );
+      }
+
+      // 5. Trigger care priority notification if priority is not ROUTINE
+      if (priority !== CarePriority.ROUTINE) {
+        await this.notificationsService.sendCarePriorityNotification(
+          userId,
+          priority
+        );
+      }
+
+      this.logger.log(`Health assessment completed for user: ${userId}`);
+    } catch (error) {
+      this.logger.error(
+        `Error during health assessment for user ${userId}:`,
+        error
+      );
+    }
+  }
+}

src/care-priority/types/care-priority.types.ts

@@ -0,0 +1,32 @@
+/**
+ * Care Priority Levels
+ *
+ * CLINICAL SAFETY PRINCIPLES:
+ * - These are NOT diagnoses
+ * - These are NOT risk scores
+ * - These are care escalation recommendations
+ * - When uncertain, escalate to higher priority
+ *
+ * LEVELS:
+ * - ROUTINE: Normal monitoring, next scheduled appointment
+ * - INCREASED_MONITORING: More frequent self-monitoring, contact provider soon
+ * - URGENT_REVIEW: Contact healthcare provider within 24 hours
+ * - EMERGENCY: Seek immediate medical attention
+ */
+export enum CarePriority {
+  ROUTINE = "ROUTINE",
+  INCREASED_MONITORING = "INCREASED_MONITORING",
+  URGENT_REVIEW = "URGENT_REVIEW",
+  EMERGENCY = "EMERGENCY",
+}
+
+/**
+ * Care Priority Result
+ *
+ * Returned by the care priority engine
+ */
+export interface CarePriorityResult {
+  priority: CarePriority;
+  reasons: string[]; // List of factors that contributed to this priority
+  timestamp: Date;
+}

src/clinic-finder/clinic-finder.controller.ts

@@ -0,0 +1,33 @@
+import { Controller, Get, HttpCode, HttpStatus, Query, UseGuards } from "@nestjs/common";
+import { ClinicFinderService } from "./clinic-finder.service";
+import { JwtAuthGuard } from "../auth/guards/jwt-auth.guard";
+
+@Controller("clinic-finder")
+@UseGuards(JwtAuthGuard)
+export class ClinicFinderController {
+  constructor(private readonly clinicFinderService: ClinicFinderService) {}
+
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  findAll(
+    @Query("city") city?: string,
+    @Query("lat") lat?: string,
+    @Query("lng") lng?: string,
+    @Query("radius") radius?: string
+  ) {
+    if (lat && lng) {
+      return this.clinicFinderService.findNearby(
+        parseFloat(lat),
+        parseFloat(lng),
+        radius ? parseInt(radius) : 5000
+      );
+    }
+
+    if (city) {
+      return this.clinicFinderService.findByCity(city);
+    }
+
+    return this.clinicFinderService.findAll();
+  }
+}
+

src/clinic-finder/clinic-finder.module.ts

@@ -0,0 +1,11 @@
+import { Module } from "@nestjs/common";
+import { ClinicFinderController } from "./clinic-finder.controller";
+import { ClinicFinderService } from "./clinic-finder.service";
+
+@Module({
+  controllers: [ClinicFinderController],
+  providers: [ClinicFinderService],
+  exports: [ClinicFinderService],
+})
+export class ClinicFinderModule {}
+

src/clinic-finder/clinic-finder.service.ts

@@ -0,0 +1,73 @@
+import { Injectable, Logger } from "@nestjs/common";
+import axios from "axios";
+import { CLINIC_LOCATIONS, ClinicLocation } from "./data/clinics.data";
+
+@Injectable()
+export class ClinicFinderService {
+  private readonly logger = new Logger(ClinicFinderService.name);
+  private readonly overpassUrl = "https://overpass-api.de/api/interpreter";
+
+  async findNearby(
+    lat: number,
+    lng: number,
+    radius: number = 5000
+  ): Promise<ClinicLocation[]> {
+    try {
+      this.logger.log(`Searching for hospitals near ${lat}, ${lng} within ${radius}m using Overpass API`);
+      
+      const query = `
+        [out:json][timeout:25];
+        (
+          node["amenity"="hospital"](around:${radius},${lat},${lng});
+          way["amenity"="hospital"](around:${radius},${lat},${lng});
+          node["amenity"="clinic"](around:${radius},${lat},${lng});
+          way["amenity"="clinic"](around:${radius},${lat},${lng});
+        );
+        out center;
+      `;
+
+      const response = await axios.post(this.overpassUrl, `data=${encodeURIComponent(query)}`);
+
+      if (response.data && response.data.elements) {
+        return response.data.elements.map((element: any) => ({
+          id: element.id.toString(),
+          name: element.tags.name || "Unnamed Hospital",
+          latitude: element.lat || element.center?.lat,
+          longitude: element.lon || element.center?.lon,
+          address: element.tags["addr:street"] 
+            ? `${element.tags["addr:housenumber"] || ""} ${element.tags["addr:street"]}`.trim()
+            : "Address not available",
+          city: element.tags["addr:city"] || "Detected",
+          country: "Nigeria",
+          phone: element.tags.phone || element.tags["contact:phone"] || "Contact via Maps",
+          isEmergency: element.tags.amenity === "hospital",
+        }));
+      }
+
+      return [];
+    } catch (error: any) {
+      this.logger.error(`Failed to fetch nearby hospitals from Overpass: ${error.message}`);
+      return this.findAll(); // Fallback to seed data on error
+    }
+  }
+
+  findAll(): ClinicLocation[] {
+    return CLINIC_LOCATIONS;
+  }
+
+  findByCity(city: string): ClinicLocation[] {
+    const normalized = city.trim().toLowerCase();
+
+    // If city is "Ikeja", include "Lagos" clinics as well, as Ikeja is part of Lagos
+    const isIkeja = normalized === "ikeja";
+
+    return CLINIC_LOCATIONS.filter((clinic) => {
+      const clinicCity = clinic.city.toLowerCase();
+      if (isIkeja) {
+        return clinicCity === "ikeja" || clinicCity === "lagos";
+      }
+      return clinicCity === normalized;
+    });
+  }
+}
+

src/clinic-finder/data/clinics.data.ts

@@ -0,0 +1,125 @@
+export interface ClinicLocation {
+  id: string;
+  name: string;
+  latitude: number;
+  longitude: number;
+  address: string;
+  city: string;
+  country: string;
+  phone?: string;
+  isEmergency?: boolean;
+}
+
+export const CLINIC_LOCATIONS: ClinicLocation[] = [
+  {
+    id: "lagos-luth",
+    name: "Lagos University Teaching Hospital",
+    latitude: 6.5069,
+    longitude: 3.3673,
+    address: "Ishaga Road, Idi-Araba, Surulere",
+    city: "Lagos",
+    country: "Nigeria",
+    phone: "+234-1-877-7000",
+    isEmergency: true,
+  },
+  {
+    id: "lagos-island-maternity",
+    name: "Island Maternity Hospital",
+    latitude: 6.4513,
+    longitude: 3.3940,
+    address: "Broad Street, Lagos Island",
+    city: "Lagos",
+    country: "Nigeria",
+    phone: "+234-1-264-3018",
+    isEmergency: true,
+  },
+  {
+    id: "abuja-national-hospital",
+    name: "National Hospital Abuja",
+    latitude: 9.0360,
+    longitude: 7.4899,
+    address: "Plot 132 Central District (Phase II), Garki",
+    city: "Abuja",
+    country: "Nigeria",
+    phone: "+234-9-234-0940",
+    isEmergency: true,
+  },
+  {
+    id: "abuja-nyanya-general",
+    name: "Nyanya General Hospital",
+    latitude: 8.9953,
+    longitude: 7.6207,
+    address: "Nyanya",
+    city: "Abuja",
+    country: "Nigeria",
+    phone: "+234-9-123-4567",
+    isEmergency: false,
+  },
+  {
+    id: "ikeja-lasuth",
+    name: "Lagos State University Teaching Hospital (LASUTH)",
+    latitude: 6.5962,
+    longitude: 3.3514,
+    address: "1-5 Oba Akinjobi Way, Ikeja",
+    city: "Ikeja",
+    country: "Nigeria",
+    phone: "+234-1-493-4500",
+    isEmergency: true,
+  },
+  {
+    id: "ikeja-medical-centre",
+    name: "Ikeja Medical Centre",
+    latitude: 6.6015,
+    longitude: 3.3421,
+    address: "11-15 Olufemi Road, Ikeja",
+    city: "Ikeja",
+    country: "Nigeria",
+    phone: "+234-1-497-2345",
+    isEmergency: true,
+  },
+  {
+    id: "reddington-hospital-ikeja",
+    name: "Reddington Hospital Ikeja",
+    latitude: 6.5921,
+    longitude: 3.3587,
+    address: "12 Isaac John St, GRA, Ikeja",
+    city: "Ikeja",
+    country: "Nigeria",
+    phone: "+234-1-271-5341",
+    isEmergency: true,
+  },
+  {
+    id: "eunice-clinic-ikeja",
+    name: "Eunice Clinic & Hospital",
+    latitude: 6.6054,
+    longitude: 3.3489,
+    address: "24 Allen Ave, Ikeja",
+    city: "Ikeja",
+    country: "Nigeria",
+    phone: "+234-803-123-4567",
+    isEmergency: false,
+  },
+  {
+    id: "nicholas-hospital-ikeja",
+    name: "St. Nicholas Hospital Ikeja",
+    latitude: 6.5901,
+    longitude: 3.3602,
+    address: "7b Maryland Est, Ikeja",
+    city: "Ikeja",
+    country: "Nigeria",
+    phone: "+234-1-280-5000",
+    isEmergency: true,
+  },
+  {
+    id: "blue-cross-ikeja",
+    name: "Blue Cross Hospital",
+    latitude: 6.6123,
+    longitude: 3.3345,
+    address: "14 Ogba Road, Ikeja",
+    city: "Ikeja",
+    country: "Nigeria",
+    phone: "+234-1-492-3456",
+    isEmergency: false,
+  },
+];
+

src/database/database.module.ts

@@ -0,0 +1,33 @@
+import { Module, Global } from "@nestjs/common";
+import { PrismaService } from "./prisma.service";
+
+/**
+ * Database Module (Prisma)
+ *
+ * ORM CHOICE: Prisma
+ *
+ * JUSTIFICATION:
+ * - Type-safe database client with excellent TypeScript support
+ * - Intuitive schema definition language
+ * - Automatic migration generation
+ * - Built-in connection pooling
+ * - Great developer experience with Prisma Studio
+ * - Strong PostgreSQL support
+ *
+ * CLINICAL SAFETY CONSIDERATIONS:
+ * - All entities will enforce strict validation at schema level
+ * - Type safety prevents invalid data operations
+ * - Audit logging capabilities via middleware
+ * - Transaction support for data integrity
+ * - No raw SQL for sensitive operations (use Prisma queries)
+ *
+ * This module is marked as @Global so PrismaService is available
+ * throughout the application without repeated imports
+ */
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class DatabaseModule {}

src/database/prisma.service.ts

@@ -0,0 +1,102 @@
+import {
+  Injectable,
+  OnModuleInit,
+  OnModuleDestroy,
+  Logger,
+} from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { Pool } from "pg";
+
+/**
+ * Prisma Service
+ *
+ * Provides database access throughout the application
+ * Handles connection lifecycle and health checks
+ *
+ * CLINICAL SAFETY CONSIDERATIONS:
+ * - All queries are type-safe
+ * - Automatic connection pooling
+ * - Transaction support for data integrity
+ * - Query logging in development
+ */
+
+@Injectable()
+export class PrismaService
+  extends PrismaClient
+  implements OnModuleInit, OnModuleDestroy
+{
+  private readonly logger = new Logger(PrismaService.name);
+
+  constructor() {
+    const pool = new Pool({
+      connectionString: process.env.DATABASE_URL,
+      max: 10, // Maintain up to 10 connections
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 10000,
+      ssl: {
+        rejectUnauthorized: false, // Required for Neon in some environments
+      },
+    });
+    
+    // Log pool errors
+    pool.on('error', (err) => {
+      this.logger.error('Unexpected error on idle client', err);
+    });
+
+    super({
+      adapter: new PrismaPg(pool),
+      log:
+        process.env.NODE_ENV === "development"
+          ? ["query", "info", "warn", "error"]
+          : ["error"],
+    });
+  }
+
+  /**
+   * Connect to database on module initialization
+   */
+  async onModuleInit() {
+    try {
+      await this.$connect();
+      this.logger.log("✅ Database connection successful");
+
+      // Test the connection
+      await this.$queryRaw`SELECT 1`;
+      this.logger.log("📊 Database health check passed");
+    } catch (error) {
+      this.logger.error("❌ Database connection failed", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Disconnect from database on module destruction
+   */
+  async onModuleDestroy() {
+    await this.$disconnect();
+    this.logger.log("🔌 Database disconnected");
+  }
+
+  /**
+   * Get database health status
+   */
+  async isHealthy(): Promise<boolean> {
+    try {
+      await this.$queryRaw`SELECT 1`;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get database info (safe, no credentials)
+   */
+  getDatabaseInfo() {
+    return {
+      provider: "postgresql",
+      isConnected: true, // If we can call this, we're connected
+    };
+  }
+}

src/education/data/data.txt

@@ -0,0 +1,123 @@
+THIS IS ACCORDING TO WHO
+
+Pre-eclampsia is a high blood pressure disorder that typically develops after 20 weeks into pregnancy. It can present serious risks to both mother and baby. Early detection and management are crucial to prevent progression to eclampsia, which involves seizures. Both conditions can be life-threatening.
+
+Diagnosis
+
+Pre-eclampsia is diagnosed based on the onset of hypertension (blood pressure ≥140/90 mm Hg) proteinuria (protein in the urine) (≥0.3 g/24 hours) after 20 weeks of gestation. Severe pre-eclampsia may include symptoms such as severe headaches, visual disturbances and upper abdominal pain.
+
+Risk factors
+
+Several factors can increase the risk of developing pre-eclampsia during pregnancy. Understanding these risk factors is essential for proactive monitoring and management. Having a risk factor doesn't always mean pre-eclampsia will occur, but closer medical supervision beyond routine screening is recommended.
+
+Several factors can increase the risk of developing pre-eclampsia, including:
+
+first-time pregnancies
+multiple pregnancies (twins, triplets, etc.)
+obesity
+pre-existing conditions such as hypertension, diabetes, or kidney disease
+family history of pre-eclampsia.
+Symptoms
+
+Symptoms of pre-eclampsia can vary significantly among individuals. While some may experience a range of noticeable symptoms, others may remain asymptomatic. It is important to be aware of potential indicators and seek medical attention if any concerns arise during pregnancy or after childbirth.
+
+Common symptoms of pre-eclampsia include:
+
+persistent high blood pressure
+proteinuria
+severe headaches
+visual disturbances (e.g., blurred vision, seeing spots)
+upper abdominal pain
+nausea and vomiting (after the first trimester)
+swelling in the hands and face.
+Complications
+
+Pre-eclampsia, if left untreated, can lead to serious complications for both mother and baby. These complications can range from short-term issues to long-term health problems. Prompt medical intervention is crucial to minimize these risks.
+
+Complications can be severe and include:
+
+eclampsia (seizures)
+HELLP syndrome (hemolysis, elevated liver enzymes, low platelet count)
+organ damage (kidneys, liver, brain)
+placental abruption
+preterm birth
+fetal growth restriction
+maternal and fetal death.
+Treatment and management
+
+The primary treatment for pre-eclampsia is the administration of magnesium sulfate to prevent seizures.
+
+The treatment and management of pre-eclampsia depend on the severity of the condition and the gestational age of the pregnancy. The goal is to prevent complications.
+
+Other management strategies include:
+
+antihypertensive medications to control blood pressure
+corticosteroids to accelerate fetal lung maturity if preterm delivery is anticipated
+close monitoring of maternal and fetal health.
+Prevention
+
+While there's no guaranteed way to prevent pre-eclampsia, certain strategies can help lower the risk. Early and consistent prenatal care is essential for monitoring and managing potential risk factors.
+
+Preventive measures focus on regular prenatal care to monitor for early signs of pre-eclampsia. Recommendations include:
+
+regular blood pressure checks
+urine tests for protein
+monitoring for symptoms such as headaches and visual disturbances
+lifestyle considerations, such as maintaining a healthy weight and activity (when permitted)
+managing pre-existing conditions, especially pre-existing high blood pressure.
+Additional prevention measures include:
+
+low dose of aspirin by 20 weeks or when antenatal care begins
+calcium supplementation during pregnancy in settings with low dietary intake
+treatment of pre-existing high blood pressure with antihypertensive medications.
+WHO response
+
+The World Health Organization (WHO) has developed guidelines to improve health during pregnancy. This includes prevention and treatment of pre-eclampsia and eclampsia and continuously reviewing evidence to see if revisions in the recommendations are needed so that improvements in care can be effected. These guidelines aim to reduce maternal and perinatal morbidity and mortality by promoting evidence-based clinical practices. Key WHO recommendations include:
+
+calcium supplementation during pregnancy in areas with low dietary calcium intake
+low-dose aspirin during pregnancy for women at high risk of pre-eclampsia
+use of magnesium sulfate for the prevention of eclampsia
+training healthcare providers in the early detection and management of pre-eclampsia
+strengthening health systems to ensure timely and effective care for pregnant women.
+By implementing these guidelines, WHO aims to address the profound inequities in maternal and perinatal health globally and achieve the health targets of the Sustainable Development Goals (SDGs). 
+
+
+END OF WHO
+
+
+
+
+The causes of preeclampsia and eclampsia are not known. These disorders previously were believed to be caused by a toxin, called “toxemia,” in the blood, but health care providers now know that is not true. Nevertheless, preeclampsia is sometimes still referred to as “toxemia.”
+
+To learn more about preeclampsia and eclampsia, scientists are investigating many factors that could contribute to the development and progression of these diseases, including:
+
+Placental abnormalities, such as insufficient blood flow
+Genetic factors
+Environmental exposures
+Nutritional factors
+Maternal immunology and autoimmune disorders
+Cardiovascular and inflammatory changes
+Hormonal imbalances 
+
+Risks During Pregnancy
+Preeclampsia during pregnancy is mild in the majority of cases.1 However, a woman can progress from mild to severe preeclampsia or to full eclampsia very quickly―even in a matter of days. Both preeclampsia and eclampsia can cause serious health problems for the mother and infant.
+
+Women with preeclampsia are at increased risk for damage to the kidneys, liver, brain, and other organ and blood systems. Preeclampsia may also affect the placenta. The condition could lead to a separation of the placenta from the uterus (referred to as placental abruption), preterm birth, and pregnancy loss or stillbirth. In some cases, preeclampsia can lead to organ failure or stroke.
+
+In severe cases, preeclampsia can develop into eclampsia, which includes seizures. Seizures in eclampsia may cause a woman to lose consciousness and twitch uncontrollably.2 If the fetus is not delivered, these conditions can cause the death of the mother and/or the fetus.
+
+Although most pregnant women in developed countries survive preeclampsia, it is still a major cause of illness and death globally.3 According to the World Health Organization, preeclampsia and eclampsia cause 14% of maternal deaths each year, or about 50,000 to 75,000 women worldwide.4
+
+
+Risks After Pregnancy
+In "uncomplicated preeclampsia," the mother's high blood pressure and other symptoms usually go back to normal within 6 weeks of the infant's birth. However, studies have shown that women who had preeclampsia are four times more likely to later develop hypertension (high blood pressure) and are twice as likely to later develop ischemic heart disease (reduced blood supply to the heart muscle, which can cause heart attacks), a blood clot in a vein, and stroke as are women who did not have preeclampsia.5
+
+Less commonly, mothers who had preeclampsia can experience permanent damage to their organs, such as their kidneys and liver. They can also experience fluid in the lungs. In the days following birth, women with preeclampsia remain at increased risk for developing eclampsia and seizures.3,6
+
+In some women, preeclampsia develops between 48 hours and 6 weeks after they deliver their baby—a condition called postpartum preeclampsia.7,8 Postpartum preeclampsia can occur in women who had preeclampsia during pregnancy and among those who did not. One study found that slightly more than one-half of women who had postpartum preeclampsia did not have preeclampsia during pregnancy.9 If a woman has seizures within 72 hours of delivery, she may have postpartum eclampsia. It is important to recognize and treat postpartum preeclampsia and eclampsia because the risk of complications may be higher than if the conditions had occurred during pregnancy.10 Postpartum preeclampsia and eclampsia can progress very quickly if not treated and may lead to stroke or death. Visit the Preeclampsia Foundation website for mor
+
+
+https://youtu.be/dqMXyDLiUqg
+
+
+Video: Overview of Preeclampsia and Eclampsia-MSD Manual Professional Edition https://www.msdmanuals.com/professional/multimedia/video/overview-of-preeclampsia-and-eclampsia?utm_source=chatgpt.com

src/education/data/education.content.ts

@@ -0,0 +1,177 @@
+export interface EducationArticle {
+  id: string;
+  title: string;
+  category: "HYPERTENSION" | "NUTRITION" | "WARNING_SIGNS" | "POSTPARTUM";
+  summary: string;
+  content: string; // Plain text or safe markdown
+  readTimeMinutes: number;
+  source: string;
+  sourceUrl?: string;
+  videoUrl?: string;
+}
+
+/**
+ * Static Education Content
+ *
+ * CLINICAL SAFETY:
+ * - Hardcoded content to ensure clinical accuracy
+ * - No dynamic generation
+ * - Curated from reputable sources (ACOG, WHO, Preeclampsia Foundation)
+ * - Non-alarmist language
+ */
+export const EDUCATION_CONTENT: EducationArticle[] = [
+  {
+    id: "understanding-bp",
+    title: "Understanding Blood Pressure in Pregnancy",
+    category: "HYPERTENSION",
+    summary:
+      "Learn what blood pressure numbers mean and why they matter during pregnancy.",
+    content: `Blood pressure is the force of your blood pushing against the walls of your arteries. It is measured with two numbers:
+
+1. Systolic (top number): The pressure when your heart beats.
+2. Diastolic (bottom number): The pressure when your heart rests between beats.
+
+In pregnancy, it's important to keep track of these numbers. A normal reading is typically below 120/80 mmHg. If your numbers are higher, your healthcare provider will want to monitor you more closely to ensure both you and your baby stay healthy.`,
+    readTimeMinutes: 3,
+    source: "World Health Organization (WHO) patient information on hypertension in pregnancy",
+    sourceUrl:
+      "https://www.who.int/health-topics/hypertension#tab=tab_1",
+    videoUrl:
+      "https://www.preeclampsia.org/video-library",
+  },
+  {
+    id: "warning-signs",
+    title: "Warning Signs to Watch For",
+    category: "WARNING_SIGNS",
+    summary:
+      "Key symptoms that should prompt you to call your healthcare provider.",
+    content: `Most pregnancies go smoothly, but knowing which symptoms to watch for can help you get care quickly if needed. Contact your provider if you experience:
+
+- Severe headaches that won't go away with medication
+- Changes in vision (blurring, flashing lights, or spots)
+- Sudden swelling in your face or hands
+- Pain in the upper right side of your belly
+- Trouble breathing
+- Nausea or vomiting (especially after mid-pregnancy)
+
+If you are unsure, it is always safer to call your provider and ask.`,
+    readTimeMinutes: 4,
+    source:
+      "Preeclampsia Foundation - 7 Signs and Symptoms Every Pregnant Woman Should Know",
+    sourceUrl:
+      "https://www.preeclampsia.org/health-information/signs-and-symptoms",
+    videoUrl:
+      "https://www.preeclampsia.org/video-library",
+  },
+  {
+    id: "nutrition-hypertension",
+    title: "Nutrition for Healthy Blood Pressure",
+    category: "NUTRITION",
+    summary: "Dietary tips to help manage blood pressure naturally.",
+    content: `Eating a balanced diet is good for you and your baby. To help support healthy blood pressure:
+
+- Stay hydrated: Drink plenty of water throughout the day.
+- Watch sodium intake: Try to limit processed foods which are often high in salt.
+- Eat plenty of fruits and vegetables: These provide essential nutrients like potassium.
+- Choose whole grains: Brown rice, oats, and whole wheat bread are great options.
+
+Always talk to your doctor or a nutritionist before making major changes to your diet.`,
+    readTimeMinutes: 3,
+    source:
+      "American College of Obstetricians and Gynecologists (ACOG) – Nutrition During Pregnancy",
+    sourceUrl:
+      "https://www.acog.org/womens-health/faqs/nutrition-during-pregnancy",
+    videoUrl: undefined,
+  },
+  {
+    id: "postpartum-care",
+    title: "Taking Care After Birth",
+    category: "POSTPARTUM",
+    summary:
+      "Why monitoring your health remains important after your baby arrives.",
+    content: `The postpartum period (after birth) is a time of recovery. It is important to continue listening to your body.
+
+Some conditions, like postpartum preeclampsia, can occur even after the baby is born. Continue to watch for severe headaches, vision changes, or shortness of breath.
+
+Make sure to attend your postpartum check-ups so your provider can ensure you are healing well.`,
+    readTimeMinutes: 2,
+    source:
+      "American College of Obstetricians and Gynecologists (ACOG) – Postpartum Preeclampsia information",
+    sourceUrl:
+      "https://www.acog.org/womens-health/faqs/preeclampsia-and-high-blood-pressure-during-pregnancy",
+    videoUrl:
+      "https://www.preeclampsia.org/video-library",
+  },
+  {
+    id: "preeclampsia-eclampsia-overview",
+    title: "Preeclampsia and Eclampsia: What You Should Know",
+    category: "HYPERTENSION",
+    summary:
+      "Overview of causes, warning signs, and care for preeclampsia and eclampsia.",
+    content: `Preeclampsia is a blood pressure condition that usually develops after 20 weeks of pregnancy. It involves high blood pressure and signs that organs such as the kidneys or liver are under strain. If it is not treated, it can progress to eclampsia, which includes seizures. Early recognition and close medical care greatly reduce the chance of serious problems.
+
+Diagnosis
+
+- Blood pressure at or above 140/90 mmHg on more than one occasion
+- Protein in the urine (proteinuria)
+- Sometimes other changes in blood tests or organ function
+
+Risk factors
+
+- First pregnancy
+- Multiple pregnancy (twins, triplets, etc.)
+- History of high blood pressure, diabetes, kidney disease, or autoimmune disease
+- Obesity
+- Family history of preeclampsia
+
+Warning symptoms
+
+- Severe or persistent headache
+- Changes in vision (blurred vision, flashing lights, or spots)
+- Pain in the upper right side of the abdomen
+- Nausea or vomiting after the first trimester
+- Sudden swelling of the face, hands, or around the eyes
+- Shortness of breath
+
+Possible complications
+
+- Seizures (eclampsia)
+- HELLP syndrome (problems with the liver and blood clotting)
+- Problems with the kidneys, liver, brain, or lungs
+- Placental abruption (the placenta pulling away from the uterus)
+- Restricted growth of the baby or early birth
+
+Treatment and monitoring
+
+- Close monitoring of blood pressure, urine, and blood tests
+- Medications to lower blood pressure when needed
+- Magnesium sulfate in some cases to help prevent seizures
+- Corticosteroids to help the baby's lungs if early delivery is likely
+- Timing of birth based on the health of you and your baby
+
+After pregnancy
+
+Preeclampsia can sometimes develop after birth (postpartum preeclampsia), usually within the first six weeks. Headache, vision changes, shortness of breath, or severe pain after delivery should be checked urgently.
+
+Long-term health
+
+Women who have had preeclampsia have a higher chance of high blood pressure, heart disease, and stroke later in life than women who did not. Regular follow-up with a primary care provider is important.
+
+Prevention and self-care
+
+- Attend all antenatal and postpartum visits
+- Have blood pressure and urine checked as recommended
+- Report warning symptoms promptly
+- Follow advice on healthy eating, activity, and weight management when appropriate
+- Take low-dose aspirin and calcium supplements if recommended by your care team
+
+This summary is based on guidance from the World Health Organization and other international expert groups.`,
+    readTimeMinutes: 8,
+    source:
+      "World Health Organization (WHO) and international guidelines on preeclampsia and eclampsia",
+    sourceUrl:
+      "https://www.who.int/health-topics/hypertension#tab=tab_1",
+    videoUrl:
+      "https://www.msdmanuals.com/professional/multimedia/video/overview-of-preeclampsia-and-eclampsia?utm_source=chatgpt.com",
+  },
+];

src/education/education.controller.ts

@@ -0,0 +1,43 @@
+import {
+  Controller,
+  Get,
+  Param,
+  Query,
+  UseGuards,
+  HttpCode,
+  HttpStatus,
+} from "@nestjs/common";
+import { EducationService } from "./education.service";
+import { JwtAuthGuard } from "../auth/guards/jwt-auth.guard";
+
+/**
+ * Education Controller
+ *
+ * ENDPOINTS:
+ * - GET /education - List all articles (optional category filter)
+ * - GET /education/:id - Get specific article
+ *
+ * RESTRICTIONS:
+ * - Authenticated users only
+ * - Read-only access
+ */
+@Controller("education")
+@UseGuards(JwtAuthGuard)
+export class EducationController {
+  constructor(private readonly educationService: EducationService) {}
+
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  findAll(@Query("category") category?: string) {
+    if (category) {
+      return this.educationService.findByCategory(category);
+    }
+    return this.educationService.findAll();
+  }
+
+  @Get(":id")
+  @HttpCode(HttpStatus.OK)
+  findOne(@Param("id") id: string) {
+    return this.educationService.findOne(id);
+  }
+}

src/education/education.module.ts

@@ -0,0 +1,22 @@
+import { Module } from "@nestjs/common";
+import { EducationController } from "./education.controller";
+import { EducationService } from "./education.service";
+
+/**
+ * Education Module
+ *
+ * RESPONSIBILITIES:
+ * CONSTRAINTS:
+ * - No personalization
+ * - No interpretation
+ * - Content delivery only
+ *
+ * To be implemented in STEP 10
+ */
+
+@Module({
+  controllers: [EducationController],
+  providers: [EducationService],
+  exports: [EducationService],
+})
+export class EducationModule {}

src/education/education.service.ts

@@ -0,0 +1,44 @@
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { EDUCATION_CONTENT, EducationArticle } from "./data/education.content";
+
+/**
+ * Education Service
+ *
+ * RESPONSIBILITIES:
+ * - Serve static, curated education content
+ * - Filter by category
+ * - Retrieve single articles
+ *
+ * CLINICAL SAFETY:
+ * - Read-only access to curated content
+ * - No dynamic user-generated content allowed
+ */
+@Injectable()
+export class EducationService {
+  /**
+   * Get all education articles
+   */
+  findAll(): EducationArticle[] {
+    return EDUCATION_CONTENT;
+  }
+
+  /**
+   * Get articles by category
+   */
+  findByCategory(category: string): EducationArticle[] {
+    return EDUCATION_CONTENT.filter((article) => article.category === category);
+  }
+
+  /**
+   * Get single article by ID
+   */
+  findOne(id: string): EducationArticle {
+    const article = EDUCATION_CONTENT.find((a) => a.id === id);
+
+    if (!article) {
+      throw new NotFoundException("Article not found");
+    }
+
+    return article;
+  }
+}

src/health.controller.ts

@@ -0,0 +1,18 @@
+import { Controller, Get } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+
+@ApiTags('Health')
+@Controller('health')
+export class HealthController {
+  @Get()
+  @ApiOperation({ summary: 'Check API health and uptime' })
+  check() {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      service: 'MaternAlert Backend',
+      version: '1.0.0',
+    };
+  }
+}

src/main.ts

@@ -0,0 +1,19 @@
+import { NestFactory } from "@nestjs/core";
+import { AppModule } from "./app.module";
+import { setupGlobalMiddleware } from "./setup";
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  setupGlobalMiddleware(app);
+
+  const port = process.env.PORT || 3000;
+  await app.listen(port, '0.0.0.0');
+
+  console.log(`\n🏥 Maternal Health Support Backend`);
+  console.log(`⚠️  CARE-SUPPORT TOOL - NOT A DIAGNOSTIC SYSTEM`);
+  console.log(`🚀 Server running on: http://localhost:${port}/api/v1`);
+  console.log(`📡 Network access: http://10.120.165.24:${port}/api/v1\n`);
+}
+
+bootstrap();

src/notifications/dto/register-push-token.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from "class-validator";
+
+export class RegisterPushTokenDto {
+  @IsNotEmpty()
+  @IsString()
+  token!: string;
+}

src/notifications/email.service.ts

@@ -0,0 +1,41 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as nodemailer from 'nodemailer';
+
+@Injectable()
+export class EmailService {
+  private readonly logger = new Logger(EmailService.name);
+  private transporter: nodemailer.Transporter;
+
+  constructor(private readonly configService: ConfigService) {
+    this.transporter = nodemailer.createTransport({
+      host: this.configService.get('SMTP_HOST'),
+      port: this.configService.get('SMTP_PORT'),
+      secure: false, // true for 465, false for other ports
+      auth: {
+        user: this.configService.get('SMTP_USER'),
+        pass: this.configService.get('SMTP_PASS'),
+      },
+    });
+  }
+
+  async sendEmail(to: string, subject: string, text: string, html?: string): Promise<boolean> {
+    try {
+      const from = this.configService.get('SMTP_FROM');
+      
+      const info = await this.transporter.sendMail({
+        from,
+        to,
+        subject,
+        text,
+        html: html || text,
+      });
+
+      this.logger.log(`Email sent successfully: ${info.messageId} to ${to}`);
+      return true;
+    } catch (error: any) {
+      this.logger.error(`Failed to send email to ${to}: ${error.message}`, error.stack);
+      return false;
+    }
+  }
+}

src/notifications/notifications.controller.ts

@@ -0,0 +1,25 @@
+import { Controller, Get, Patch, Post, Param, Body, UseGuards, Request } from "@nestjs/common";
+import { NotificationsService } from "./notifications.service";
+import { JwtAuthGuard } from "../auth/guards/jwt-auth.guard";
+import { RegisterPushTokenDto } from "./dto/register-push-token.dto";
+
+@Controller("notifications")
+@UseGuards(JwtAuthGuard)
+export class NotificationsController {
+  constructor(private readonly notificationsService: NotificationsService) {}
+
+  @Get()
+  async getUserNotifications(@Request() req: any) {
+    return this.notificationsService.getNotificationHistory(req.user.id);
+  }
+
+  @Post("register")
+  async registerPushToken(@Request() req: any, @Body() dto: RegisterPushTokenDto) {
+    return this.notificationsService.registerPushToken(req.user.id, dto.token);
+  }
+
+  @Patch(":id/read")
+  async markAsRead(@Param("id") id: string, @Request() req: any) {
+    return this.notificationsService.markAsRead(id, req.user.id);
+  }
+}

src/notifications/notifications.module.ts

@@ -0,0 +1,31 @@
+import { Module } from "@nestjs/common";
+import { NotificationsService } from "./notifications.service";
+import { NotificationsController } from "./notifications.controller";
+import { EmailService } from "./email.service";
+
+/**
+ * Notifications Module
+ *
+ * RESPONSIBILITIES:
+ * - Send care escalation alerts
+ * - Template-based messaging only
+ * - No dynamic medical text generation
+ *
+ * CLINICAL SAFETY CONSTRAINTS:
+ * - No fear-based language
+ * - No predictions
+ * - Predefined templates only
+ * - Clear, actionable guidance
+ *
+ * DELIVERY:
+ * - Currently stub implementation (console logging)
+ * - Ready for integration with email/SMS services
+ * - Examples: SendGrid, Twilio, AWS SNS
+ */
+
+@Module({
+  controllers: [NotificationsController],
+  providers: [NotificationsService, EmailService],
+  exports: [NotificationsService, EmailService],
+})
+export class NotificationsModule {}