@blackcode_sa/metaestetics-api 1.7.1 → 1.7.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/admin/documentation-templates/document-manager.admin.ts

@@ -245,6 +245,7 @@ export class DocumentManagerAdminService {
         title: template.title,
         isUserForm: filledDocumentData.isUserForm,
         isRequired: filledDocumentData.isRequired,
+        sortingOrder: templateRef.sortingOrder,
         status: filledDocumentData.status,
         path: docRef.path,
       };

package/src/services/patient/utils/medical.utils.ts

@@ -25,6 +25,7 @@ import {
   PATIENTS_COLLECTION,
   PATIENT_MEDICAL_INFO_COLLECTION,
   PatientDoctor,
+  type PatientProfile,
 } from "../../../types/patient";
 import {
   createPatientMedicalInfoSchema,
@@ -43,6 +44,7 @@ import { z } from "zod";
 import { AuthError } from "../../../errors/auth.errors";
 import { UserRole } from "../../../types";
 import { getMedicalInfoDocRef, getPatientDocRef } from "./docs.utils";
+import { getPractitionerProfileByUserRef } from "./practitioner.utils";
 
 // Pomoćna funkcija za proveru i inicijalizaciju medical info dokumenta
 export const ensureMedicalInfoExists = async (
@@ -117,32 +119,29 @@ const checkMedicalAccessUtil = async (
     throw new Error("Patient profile not found");
   }
 
-  const patientData = patientDoc.data();
+  const patientData = patientDoc.data() as PatientProfile;
 
   // Proveri da li je korisnik vlasnik profila
   if (patientData.userRef === userRef) return;
 
-  // Proveri da li korisnik ima potrebnu ulogu
-  if (
-    !(
-      userRoles.includes(UserRole.PRACTITIONER) ||
-      userRoles.includes(UserRole.PATIENT)
-    )
-  ) {
-    throw new AuthError(
-      "Nedozvoljen pristup medicinskim informacijama",
-      "AUTH/UNAUTHORIZED_ACCESS",
-      403
+  // Ako je doktor, proveri da li je povezan sa pacijentom
+  if (userRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(
+      db,
+      userRef
     );
-  }
 
-  // Ako je doktor, proveri da li je povezan sa pacijentom
-  if (
-    userRoles.includes(UserRole.PRACTITIONER) &&
-    !userRoles.includes(UserRole.PATIENT)
-  ) {
-    const isAssignedDoctor = patientData.doctors?.some(
-      (doctor: PatientDoctor) => doctor.userRef === userRef && doctor.isActive
+    if (!practitionerProfile) {
+      throw new AuthError(
+        "Practitioner profile not found",
+        "AUTH/UNAUTHORIZED_ACCESS",
+        403
+      );
+    }
+
+    // Check if practitioner's ID is in the patient's doctorIds array
+    const isAssignedDoctor = patientData.doctorIds?.includes(
+      practitionerProfile.id
     );
 
     if (!isAssignedDoctor) {
@@ -190,8 +189,10 @@ export const getMedicalInfoUtil = async (
     throw new Error("Medicinske informacije nisu pronađene");
   }
 
+  // The schema will transform raw timestamp objects to Timestamp instances
   return patientMedicalInfoSchema.parse(snapshot.data());
 };
+
 // Funkcije za rad sa vitalnim statistikama
 export const updateVitalStatsUtil = async (
   db: Firestore,
@@ -235,10 +236,12 @@ export const updateAllergyUtil = async (
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
 
-  const doc = await getDoc(getMedicalInfoDocRef(db, patientId));
-  if (!doc.exists()) throw new Error("Medical info not found");
+  const docSnapshot = await getDoc(getMedicalInfoDocRef(db, patientId));
+  if (!docSnapshot.exists()) throw new Error("Medical info not found");
+
+  // Parse through schema to ensure proper Timestamp objects
+  const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
 
-  const medicalInfo = doc.data() as PatientMedicalInfo;
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }

package/src/services/patient/utils/practitioner.utils.ts

@@ -17,6 +17,10 @@ import {
   PATIENTS_COLLECTION,
 } from "../../../types/patient";
 import { getSensitiveInfoDocRef } from "./docs.utils";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../../types/practitioner";
 
 /**
  * Retrieves all patients associated with a specific practitioner with pagination support.
@@ -156,3 +160,101 @@ export const getPatientsByPractitionerWithDetailsUtil = async (
     );
   }
 };
+
+/**
+ * Retrieves a practitioner profile by ID
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} practitionerId - ID of the practitioner to retrieve
+ * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
+ */
+export const getPractitionerProfile = async (
+  db: Firestore,
+  practitionerId: string
+): Promise<Practitioner | null> => {
+  try {
+    console.log(
+      `[getPractitionerProfile] Fetching practitioner with ID: ${practitionerId}`
+    );
+
+    const practitionerRef = doc(db, PRACTITIONERS_COLLECTION, practitionerId);
+    const practitionerSnapshot = await getDoc(practitionerRef);
+
+    if (!practitionerSnapshot.exists()) {
+      console.log(
+        `[getPractitionerProfile] Practitioner with ID ${practitionerId} not found`
+      );
+      return null;
+    }
+
+    const practitioner = practitionerSnapshot.data() as Practitioner;
+    console.log(
+      `[getPractitionerProfile] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
+    );
+
+    return practitioner;
+  } catch (error) {
+    console.error(
+      `[getPractitionerProfile] Error fetching practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve practitioner: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};
+
+/**
+ * Retrieves a practitioner profile by user reference ID
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} userRef - Firebase Auth user ID reference
+ * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
+ */
+export const getPractitionerProfileByUserRef = async (
+  db: Firestore,
+  userRef: string
+): Promise<Practitioner | null> => {
+  try {
+    console.log(
+      `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
+    );
+
+    const practitionersCollection = collection(db, PRACTITIONERS_COLLECTION);
+    const q = query(
+      practitionersCollection,
+      where("userRef", "==", userRef),
+      limit(1)
+    );
+
+    const querySnapshot = await getDocs(q);
+
+    if (querySnapshot.empty) {
+      console.log(
+        `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
+      );
+      return null;
+    }
+
+    const practitionerDoc = querySnapshot.docs[0];
+    const practitioner = practitionerDoc.data() as Practitioner;
+
+    console.log(
+      `[getPractitionerProfileByUserRef] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
+    );
+
+    return practitioner;
+  } catch (error) {
+    console.error(
+      `[getPractitionerProfileByUserRef] Error fetching practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve practitioner by userRef: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};

package/src/types/appointment/index.ts

@@ -94,6 +94,7 @@ export interface LinkedFormInfo {
   title: string; // For display, usually from DocumentTemplate.title
   isUserForm: boolean;
   isRequired?: boolean;
+  sortingOrder?: number;
   status: FilledDocumentStatus; // Status of the filled form (e.g., draft, completed, signed)
   path: string; // Full Firestore path to the filled document (e.g., appointments/{aid}/user-forms/{fid})
   submittedAt?: Timestamp;

package/src/types/patient/medical-info.types.ts

@@ -34,7 +34,7 @@ export interface PatientMedicalInfo {
     condition: BlockingCondition;
     diagnosedAt: Timestamp;
     isActive: boolean;
-    notes?: string;
+    notes?: string | null;
   }[];
 
   contraindications: {
@@ -42,7 +42,7 @@ export interface PatientMedicalInfo {
     lastOccurrence: Timestamp;
     frequency: "rare" | "occasional" | "frequent";
     isActive: boolean;
-    notes?: string;
+    notes?: string | null;
   }[];
 
   allergies: Allergy[];

package/src/validations/common.schema.ts

@@ -1,9 +1,20 @@
 import { z } from "zod";
 import { Timestamp } from "firebase/firestore";
 
-export const timestampSchema = z.object({
-  seconds: z.number(),
-  nanoseconds: z.number(),
-});
+// Create a custom schema for Timestamp that properly handles both raw objects and Timestamp instances
+export const timestampSchema = z
+  .union([
+    z.object({
+      seconds: z.number(),
+      nanoseconds: z.number(),
+    }),
+    z.instanceof(Timestamp),
+  ])
+  .transform((data) => {
+    if (data instanceof Timestamp) {
+      return data;
+    }
+    return new Timestamp(data.seconds, data.nanoseconds);
+  });
 
 // export const timestampSchema = z.instanceof(Timestamp);