fix(services): add facility validation and clean up code

add checks to verify patients are linked to a facility across multiple services to prevent runtime null errors
standardize code formatting for imports, indentation, and line breaks across all service files
fix null handling in facilities service to safely access facility data and return accurate linked status
add missing trailing newline in facilities service file

src/anc-visit/anc-visit.service.ts

@@ -1,4 +1,8 @@
-import { Injectable, NotFoundException } from "@nestjs/common";
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from "@nestjs/common";
 import { CreateAncVisitDto } from "./dto/create-anc-visit.dto";
 import { PrismaService } from "src/database/prisma.service";
 import { calculateRisk } from "./utils/calculate-risk";
@@ -7,190 +11,150 @@ import { calculateRisk } from "./utils/calculate-risk";
 export class AncVisitService {
   constructor(private readonly prisma: PrismaService) {}
 
-async create(
-  dto: CreateAncVisitDto,
-  healthcareWorkerId: string,
-) {
-  const healthcareWorker =
-    await this.prisma.healthcareWorker.findUnique({
+  async create(dto: CreateAncVisitDto, healthcareWorkerId: string) {
+    const healthcareWorker = await this.prisma.healthcareWorker.findUnique({
       where: {
         id: healthcareWorkerId,
       },
     });
 
-  if (!healthcareWorker) {
-    throw new NotFoundException(
-      "Healthcare worker not found",
-    );
-  }
+    if (!healthcareWorker) {
+      throw new NotFoundException("Healthcare worker not found");
+    }
 
-  const patient =
-    await this.prisma.patient.findFirst({
+    const patient = await this.prisma.patient.findFirst({
       where: {
         id: dto.patientId,
-        facilityId:
-          healthcareWorker.facilityId,
+        facilityId: healthcareWorker.facilityId,
       },
     });
 
-  if (!patient) {
-    throw new NotFoundException(
-      "Patient not found",
-    );
-  }
+    if (!patient) {
+      throw new NotFoundException("Patient not found");
+    }
 
-  const riskLevel = calculateRisk({
-    systolic:
-      dto.bloodPressureSystolic,
-    diastolic:
-      dto.bloodPressureDiastolic,
-    urineProtein:
-      dto.urineProtein,
-  });
-
-  const visit =
-    await this.prisma.aNCVisit.create({
+    if (!patient.facilityId) {
+      throw new BadRequestException("Patient is not linked to a facility");
+    }
+
+    const riskLevel = calculateRisk({
+      systolic: dto.bloodPressureSystolic,
+      diastolic: dto.bloodPressureDiastolic,
+      urineProtein: dto.urineProtein,
+    });
+
+    const visit = await this.prisma.aNCVisit.create({
       data: {
         patientId: patient.id,
-        facilityId:
-          patient.facilityId,
+        facilityId: patient.facilityId,
         healthcareWorkerId,
 
-        visitDate: dto.visitDate
-          ? new Date(dto.visitDate)
-          : new Date(),
+        visitDate: dto.visitDate ? new Date(dto.visitDate) : new Date(),
 
-        gestationalAge:
-          dto.gestationalAge,
+        gestationalAge: dto.gestationalAge,
         weight: dto.weight,
 
-        bloodPressureSystolic:
-          dto.bloodPressureSystolic,
+        bloodPressureSystolic: dto.bloodPressureSystolic,
 
-        bloodPressureDiastolic:
-          dto.bloodPressureDiastolic,
+        bloodPressureDiastolic: dto.bloodPressureDiastolic,
 
-        urineProtein:
-          dto.urineProtein,
+        urineProtein: dto.urineProtein,
 
-        fundalHeight:
-          dto.fundalHeight,
+        fundalHeight: dto.fundalHeight,
 
-        fetalHeartRate:
-          dto.fetalHeartRate,
+        fetalHeartRate: dto.fetalHeartRate,
 
-        fetalMovement:
-          dto.fetalMovement,
+        fetalMovement: dto.fetalMovement,
 
-        haemoglobin:
-          dto.haemoglobin,
+        haemoglobin: dto.haemoglobin,
 
-        temperature:
-          dto.temperature,
+        temperature: dto.temperature,
 
-        remarks:
-          dto.remarks,
+        remarks: dto.remarks,
 
-        nextAppointmentDate:
-          dto.nextAppointmentDate
-            ? new Date(
-                dto.nextAppointmentDate,
-              )
-            : null,
+        nextAppointmentDate: dto.nextAppointmentDate
+          ? new Date(dto.nextAppointmentDate)
+          : null,
 
         riskLevel,
       },
     });
 
-  /**
-   * Update patient's latest risk snapshot
-   */
-  await this.prisma.patient.update({
-    where: {
-      id: patient.id,
-    },
-    data: {
-      latestRiskLevel: riskLevel,
-      lastVisitDate:
-        visit.visitDate,
-    },
-  });
-
-  /**
-   * Create appointment
-   */
-  if (dto.nextAppointmentDate) {
-    await this.prisma.appointment.create({
-      data: {
-        userId: patient.userId,
-        patientId: patient.id,
-        facilityId:
-          patient.facilityId,
-        title:
-          "Antenatal Care Visit",
-        type: "ANC",
-        dateTime: new Date(
-          dto.nextAppointmentDate,
-        ),
-      },
-    });
-  }
-
-  /**
-   * Close old unresolved alerts
-   * if patient is no longer high risk.
-   */
-  if (
-    riskLevel === "LOW" ||
-    riskLevel === "MODERATE"
-  ) {
-    await this.prisma.alert.updateMany({
+    /**
+     * Update patient's latest risk snapshot
+     */
+    await this.prisma.patient.update({
       where: {
-        patientId: patient.id,
-        isResolved: false,
+        id: patient.id,
       },
       data: {
-        isResolved: true,
-        resolvedAt: new Date(),
+        latestRiskLevel: riskLevel,
+        lastVisitDate: visit.visitDate,
       },
     });
-  }
 
-  /**
-   * Create new alert
-   */
-  if (
-    riskLevel === "HIGH" ||
-    riskLevel === "EMERGENCY"
-  ) {
-    const existingAlert =
-      await this.prisma.alert.findFirst({
+    /**
+     * Create appointment
+     */
+    if (dto.nextAppointmentDate) {
+      await this.prisma.appointment.create({
+        data: {
+          userId: patient.userId,
+          patientId: patient.id,
+          facilityId: patient.facilityId,
+          title: "Antenatal Care Visit",
+          type: "ANC",
+          dateTime: new Date(dto.nextAppointmentDate),
+        },
+      });
+    }
+
+    /**
+     * Close old unresolved alerts
+     * if patient is no longer high risk.
+     */
+    if (riskLevel === "LOW" || riskLevel === "MODERATE") {
+      await this.prisma.alert.updateMany({
         where: {
           patientId: patient.id,
           isResolved: false,
-          type: riskLevel,
+        },
+        data: {
+          isResolved: true,
+          resolvedAt: new Date(),
         },
       });
+    }
 
-    if (!existingAlert) {
-      await this.prisma.alert.create({
-        data: {
-          facilityId:
-            patient.facilityId,
-          patientId:
-            patient.id,
+    /**
+     * Create new alert
+     */
+    if (riskLevel === "HIGH" || riskLevel === "EMERGENCY") {
+      const existingAlert = await this.prisma.alert.findFirst({
+        where: {
+          patientId: patient.id,
+          isResolved: false,
           type: riskLevel,
-          message:
-            riskLevel === "EMERGENCY"
-              ? "Severely elevated blood pressure detected."
-              : "High-risk pregnancy detected during ANC visit.",
         },
       });
+
+      if (!existingAlert) {
+        await this.prisma.alert.create({
+          data: {
+            facilityId: patient.facilityId,
+            patientId: patient.id,
+            type: riskLevel,
+            message:
+              riskLevel === "EMERGENCY"
+                ? "Severely elevated blood pressure detected."
+                : "High-risk pregnancy detected during ANC visit.",
+          },
+        });
+      }
     }
-  }
 
-  return visit;
-}
+    return visit;
+  }
 
   async getPatientVisits(patientId: string) {
     const patient = await this.prisma.patient.findUnique({
@@ -298,24 +262,18 @@ async create(
     return defaulters.sort((a, b) => b.daysOverdue - a.daysOverdue);
   }
 
-  async getPatientSummary(
-  patientId: string,
-) {
-  const patient =
-    await this.prisma.patient.findUnique({
+  async getPatientSummary(patientId: string) {
+    const patient = await this.prisma.patient.findUnique({
       where: {
         id: patientId,
       },
     });
 
-  if (!patient) {
-    throw new NotFoundException(
-      "Patient not found",
-    );
-  }
+    if (!patient) {
+      throw new NotFoundException("Patient not found");
+    }
 
-  const visits =
-    await this.prisma.aNCVisit.findMany({
+    const visits = await this.prisma.aNCVisit.findMany({
       where: {
         patientId,
       },
@@ -324,76 +282,57 @@ async create(
       },
     });
 
-  if (!visits.length) {
-    return {
-      totalVisits: 0,
-      lastVisitDate: null,
-      nextAppointmentDate: null,
-      riskLevel: "LOW",
-      missedAppointments: 0,
-      bpTrend: "UNKNOWN",
-      lastBloodPressure: null,
-    };
-  }
+    if (!visits.length) {
+      return {
+        totalVisits: 0,
+        lastVisitDate: null,
+        nextAppointmentDate: null,
+        riskLevel: "LOW",
+        missedAppointments: 0,
+        bpTrend: "UNKNOWN",
+        lastBloodPressure: null,
+      };
+    }
 
-  const latestVisit =
-    visits[visits.length - 1];
+    const latestVisit = visits[visits.length - 1];
 
-  const today = new Date();
+    const today = new Date();
 
-  const missedAppointments =
-    visits.filter(
-      (v) =>
-        v.nextAppointmentDate &&
-        v.nextAppointmentDate < today,
+    const missedAppointments = visits.filter(
+      (v) => v.nextAppointmentDate && v.nextAppointmentDate < today,
     ).length;
 
-  let bpTrend = "STABLE";
-
-  const bpVisits = visits.filter(
-    (v) =>
-      v.bloodPressureSystolic &&
-      v.bloodPressureDiastolic,
-  );
-
-  if (bpVisits.length >= 2) {
-    const last =
-      bpVisits[bpVisits.length - 1];
-
-    const previous =
-      bpVisits[bpVisits.length - 2];
-
-    if (
-      last.bloodPressureSystolic! >
-      previous.bloodPressureSystolic!
-    ) {
-      bpTrend = "RISING";
-    } else if (
-      last.bloodPressureSystolic! <
-      previous.bloodPressureSystolic!
-    ) {
-      bpTrend = "FALLING";
+    let bpTrend = "STABLE";
+
+    const bpVisits = visits.filter(
+      (v) => v.bloodPressureSystolic && v.bloodPressureDiastolic,
+    );
+
+    if (bpVisits.length >= 2) {
+      const last = bpVisits[bpVisits.length - 1];
+
+      const previous = bpVisits[bpVisits.length - 2];
+
+      if (last.bloodPressureSystolic! > previous.bloodPressureSystolic!) {
+        bpTrend = "RISING";
+      } else if (
+        last.bloodPressureSystolic! < previous.bloodPressureSystolic!
+      ) {
+        bpTrend = "FALLING";
+      }
     }
-  }
 
-  return {
-    totalVisits: visits.length,
-    lastVisitDate:
-      latestVisit.visitDate,
-    nextAppointmentDate:
-      latestVisit.nextAppointmentDate,
-    riskLevel:
-      latestVisit.riskLevel,
-    missedAppointments,
-    bpTrend,
-    lastBloodPressure: {
-      systolic:
-        latestVisit
-          .bloodPressureSystolic,
-      diastolic:
-        latestVisit
-          .bloodPressureDiastolic,
-    },
-  };
-}
+    return {
+      totalVisits: visits.length,
+      lastVisitDate: latestVisit.visitDate,
+      nextAppointmentDate: latestVisit.nextAppointmentDate,
+      riskLevel: latestVisit.riskLevel,
+      missedAppointments,
+      bpTrend,
+      lastBloodPressure: {
+        systolic: latestVisit.bloodPressureSystolic,
+        diastolic: latestVisit.bloodPressureDiastolic,
+      },
+    };
+  }
 }

src/appointments/appointments.service.ts

@@ -1,8 +1,12 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { PrismaService } from '../database/prisma.service';
-import { CreateAppointmentDto } from './dto/create-appointment.dto';
-import { UpdateAppointmentDto } from './dto/update-appointment.dto';
-import { Appointment } from '@prisma/client';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from "@nestjs/common";
+import { PrismaService } from "../database/prisma.service";
+import { CreateAppointmentDto } from "./dto/create-appointment.dto";
+import { UpdateAppointmentDto } from "./dto/update-appointment.dto";
+import { Appointment } from "@prisma/client";
 
 @Injectable()
 export class AppointmentsService {
@@ -12,30 +16,28 @@ export class AppointmentsService {
     healthcareWorkerId: string,
     dto: CreateAppointmentDto,
   ): Promise<Appointment> {
-    const worker =
-      await this.prisma.healthcareWorker.findUnique({
-        where: {
-          id: healthcareWorkerId,
-        },
-      });
+    const worker = await this.prisma.healthcareWorker.findUnique({
+      where: {
+        id: healthcareWorkerId,
+      },
+    });
 
     if (!worker) {
-      throw new NotFoundException(
-        "Healthcare worker not found",
-      );
+      throw new NotFoundException("Healthcare worker not found");
     }
 
-    const patient =
-      await this.prisma.patient.findUnique({
-        where: {
-          id: dto.patientId,
-        },
-      });
+    const patient = await this.prisma.patient.findUnique({
+      where: {
+        id: dto.patientId,
+      },
+    });
 
     if (!patient) {
-      throw new NotFoundException(
-        "Patient not found",
-      );
+      throw new NotFoundException("Patient not found");
+    }
+
+    if (!patient.facilityId) {
+      throw new BadRequestException("Patient is not linked to a facility");
     }
 
     return this.prisma.appointment.create({
@@ -52,20 +54,15 @@ export class AppointmentsService {
     });
   }
 
-  async findAll(
-    healthcareWorkerId: string,
-  ): Promise<Appointment[]> {
-    const worker =
-      await this.prisma.healthcareWorker.findUnique({
-        where: {
-          id: healthcareWorkerId,
-        },
-      });
+  async findAll(healthcareWorkerId: string): Promise<Appointment[]> {
+    const worker = await this.prisma.healthcareWorker.findUnique({
+      where: {
+        id: healthcareWorkerId,
+      },
+    });
 
     if (!worker) {
-      throw new NotFoundException(
-        "Healthcare worker not found",
-      );
+      throw new NotFoundException("Healthcare worker not found");
     }
 
     return this.prisma.appointment.findMany({
@@ -82,33 +79,26 @@ export class AppointmentsService {
     });
   }
 
-  async findOne(
-    id: string,
-    healthcareWorkerId: string,
-  ) {
-    const worker =
-      await this.prisma.healthcareWorker.findUnique({
-        where: {
-          id: healthcareWorkerId,
-        },
-      });
-
-    const appointment =
-      await this.prisma.appointment.findFirst({
-        where: {
-          id,
-          facilityId: worker?.facilityId,
-        },
-        include: {
-          patient: true,
-          facility: true,
-        },
-      });
+  async findOne(id: string, healthcareWorkerId: string) {
+    const worker = await this.prisma.healthcareWorker.findUnique({
+      where: {
+        id: healthcareWorkerId,
+      },
+    });
+
+    const appointment = await this.prisma.appointment.findFirst({
+      where: {
+        id,
+        facilityId: worker?.facilityId,
+      },
+      include: {
+        patient: true,
+        facility: true,
+      },
+    });
 
     if (!appointment) {
-      throw new NotFoundException(
-        "Appointment not found",
-      );
+      throw new NotFoundException("Appointment not found");
     }
 
     return appointment;
@@ -119,10 +109,7 @@ export class AppointmentsService {
     healthcareWorkerId: string,
     dto: UpdateAppointmentDto,
   ) {
-    await this.findOne(
-      id,
-      healthcareWorkerId,
-    );
+    await this.findOne(id, healthcareWorkerId);
 
     return this.prisma.appointment.update({
       where: {
@@ -137,14 +124,8 @@ export class AppointmentsService {
     });
   }
 
-  async remove(
-    id: string,
-    healthcareWorkerId: string,
-  ) {
-    await this.findOne(
-      id,
-      healthcareWorkerId,
-    );
+  async remove(id: string, healthcareWorkerId: string) {
+    await this.findOne(id, healthcareWorkerId);
 
     await this.prisma.appointment.delete({
       where: {

src/facilities/facilities.service.ts

@@ -56,7 +56,12 @@ export class FacilitiesService {
 
   async update(
     id: string,
-    data: { name?: string; address?: string; phone?: string; isActive?: boolean },
+    data: {
+      name?: string;
+      address?: string;
+      phone?: string;
+      isActive?: boolean;
+    },
   ) {
     return this.prisma.facility.update({ where: { id }, data });
   }
@@ -230,14 +235,18 @@ export class FacilitiesService {
       },
     });
 
-    if (!patient) return { linked: false };
-
+    
+    if (!patient || !patient.facility) {
+      return {
+        linked: false,
+      };
+    }
     return {
-      linked: true,
+      linked: !!patient.facility,
       facilityId: patient.facilityId,
-      facilityName: patient.facility.name,
-      facilityAddress: patient.facility.address,
-      facilityPhone: patient.facility.phone,
+      facilityName: patient.facility?.name ?? null,
+      facilityAddress: patient.facility?.address ?? null,
+      facilityPhone: patient.facility?.phone ?? null,
       patientCode: patient.patientId,
       linkedAt: patient.createdAt,
     };
@@ -262,4 +271,4 @@ export class FacilitiesService {
       `Patient ${userId} unlinked from facility ${patient.facilityId}`,
     );
   }
-}
+}

src/patients/patients.service.ts

@@ -200,6 +200,11 @@ export class PatientsService {
   }
 
   async getDefaulters(facilityId: string) {
+
+    if (!facilityId) {
+    return [];
+  }
+  
     const sevenDaysAgo = new Date();
 
     sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);

src/referral/referral.service.ts

@@ -1,12 +1,14 @@
 // ─── referrals.service.ts ───────────────────────────────────────────────────
 
-import { Injectable, NotFoundException } from "@nestjs/common";
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from "@nestjs/common";
 import { PrismaService } from "../database/prisma.service";
 
 import { CreateReferralDto } from "./dto/create-referral-dto";
 
-
-
 export interface UpdateReferralDto {
   status: "PENDING" | "ACCEPTED" | "COMPLETED" | "CANCELLED";
 }
@@ -15,63 +17,56 @@ export interface UpdateReferralDto {
 export class ReferralsService {
   constructor(private readonly prisma: PrismaService) {}
 
- async create(
-  dto: CreateReferralDto,
-  facilityId: string,
-) {
-  const patient =
-    await this.prisma.patient.findFirst({
+  async create(dto: CreateReferralDto, facilityId: string) {
+    const patient = await this.prisma.patient.findFirst({
       where: {
         id: dto.patientId,
         facilityId,
       },
     });
 
-  if (!patient) {
-    throw new NotFoundException(
-      'Patient not found',
-    );
+    if (!patient) {
+      throw new NotFoundException("Patient not found");
+    }
+
+    if (!patient.facilityId) {
+      throw new BadRequestException("Patient is not linked to a facility");
+    }
+
+    return this.prisma.referral.create({
+      data: {
+        patientId: patient.id,
+        fromFacilityId: facilityId,
+        toFacilityId: dto.toFacilityId,
+        reason: dto.reason,
+        notes: dto.notes,
+      },
+    });
   }
 
-  return this.prisma.referral.create({
-    data: {
-      patientId: patient.id,
-      fromFacilityId: facilityId,
-      toFacilityId:
-        dto.toFacilityId,
-      reason: dto.reason,
-      notes: dto.notes,
-    },
-  });
-}
-
-async accept(
-  referralId: string,
-) {
-  return this.prisma.referral.update({
-    where: {
-      id: referralId,
-    },
-    data: {
-      status: 'ACCEPTED',
-      acceptedAt: new Date(),
-    },
-  });
-}
+  async accept(referralId: string) {
+    return this.prisma.referral.update({
+      where: {
+        id: referralId,
+      },
+      data: {
+        status: "ACCEPTED",
+        acceptedAt: new Date(),
+      },
+    });
+  }
 
-async complete(
-  referralId: string,
-) {
-  return this.prisma.referral.update({
-    where: {
-      id: referralId,
-    },
-    data: {
-      status: 'COMPLETED',
-      completedAt: new Date(),
-    },
-  });
-}
+  async complete(referralId: string) {
+    return this.prisma.referral.update({
+      where: {
+        id: referralId,
+      },
+      data: {
+        status: "COMPLETED",
+        completedAt: new Date(),
+      },
+    });
+  }
 
   async findAll(facilityId?: string) {
     return this.prisma.referral.findMany({
@@ -151,5 +146,3 @@ async complete(
     return { total, pending, accepted, completed, cancelled };
   }
 }
-
-