@blackcode_sa/metaestetics-api 1.14.50 → 1.14.52

package/package.json

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

package/src/services/appointment/utils/form-initialization.utils.ts

@@ -1,10 +1,11 @@
-import { Firestore, collection, doc, addDoc, deleteDoc, getDocs, query, where, serverTimestamp, getDoc } from 'firebase/firestore';
+import { Firestore, collection, doc, addDoc, deleteDoc, getDocs, query, where, serverTimestamp, getDoc, updateDoc } from 'firebase/firestore';
 import {
   DocumentTemplate,
   FilledDocumentStatus,
   DOCTOR_FORMS_SUBCOLLECTION,
   USER_FORMS_SUBCOLLECTION,
   DOCUMENTATION_TEMPLATES_COLLECTION,
+  FilledDocument,
 } from '../../../types/documentation-templates';
 import {
   APPOINTMENTS_COLLECTION,
@@ -18,6 +19,95 @@ export interface InitializeExtendedProcedureFormsResult {
   allLinkedFormIds: string[];
 }
 
+/**
+ * Determines if a form template is procedure-specific or general/shared
+ * Uses explicit tags first, then falls back to heuristics
+ * 
+ * Priority order:
+ * 1. "procedure-specific" tag → always procedure-specific
+ * 2. "shared" tag → always shared
+ * 3. Consent-related tags ("consent", "consent-form") → procedure-specific
+ * 4. Title contains "consent" → procedure-specific
+ * 5. Default → shared (general forms)
+ * 
+ * @param template DocumentTemplate to check
+ * @returns true if procedure-specific, false if general/shared
+ */
+function isProcedureSpecificForm(template: DocumentTemplate): boolean {
+  const tags = template.tags || [];
+  const titleLower = template.title.toLowerCase();
+  
+  // Priority 1: Explicit "procedure-specific" tag → always procedure-specific
+  if (tags.includes('procedure-specific')) {
+    return true;
+  }
+  
+  // Priority 2: Explicit "shared" tag → always shared
+  if (tags.includes('shared')) {
+    return false;
+  }
+  
+  // Priority 3: Consent-related tags → procedure-specific
+  if (tags.some(tag => {
+    const tagLower = tag.toLowerCase();
+    return tagLower.includes('consent') || tagLower === 'consent-form';
+  })) {
+    return true;
+  }
+  
+  // Priority 4: Check title for "consent" → procedure-specific
+  if (titleLower.includes('consent')) {
+    return true;
+  }
+  
+  // Priority 5: Default → shared (general forms)
+  return false;
+}
+
+/**
+ * Checks if a form with the given templateId already exists in the appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param templateId Template ID to check
+ * @param isUserForm Whether to check user-forms or doctor-forms subcollection
+ * @returns Existing FilledDocument or null if not found
+ */
+async function findExistingFormByTemplate(
+  db: Firestore,
+  appointmentId: string,
+  templateId: string,
+  isUserForm: boolean
+): Promise<FilledDocument | null> {
+  const formSubcollection = isUserForm
+    ? USER_FORMS_SUBCOLLECTION
+    : DOCTOR_FORMS_SUBCOLLECTION;
+  
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  const formsCollectionRef = collection(appointmentRef, formSubcollection);
+  
+  const q = query(
+    formsCollectionRef,
+    where('templateId', '==', templateId)
+  );
+  
+  const querySnapshot = await getDocs(q);
+  
+  if (querySnapshot.empty) {
+    return null;
+  }
+  
+  // Return the first matching form (should only be one for general forms)
+  const docSnap = querySnapshot.docs[0];
+  const data = docSnap.data() as FilledDocument;
+  
+  // Ensure id is populated from Firestore document ID if not in data
+  if (!data.id) {
+    data.id = docSnap.id;
+  }
+  
+  return data;
+}
+
 /**
  * Initializes forms for an extended procedure using client-side Firestore
  * Similar to DocumentManagerAdminService but for client-side usage
@@ -94,7 +184,67 @@ export async function initializeFormsForExtendedProcedure(
       ? USER_FORMS_SUBCOLLECTION
       : DOCTOR_FORMS_SUBCOLLECTION;
 
-    // Create form document in subcollection
+    // Check if form is procedure-specific or general/shared
+    const isProcedureSpecific = isProcedureSpecificForm(template);
+
+    // For general/shared forms, check if form already exists in appointment
+    let existingForm: FilledDocument | null = null;
+    if (!isProcedureSpecific) {
+      try {
+        existingForm = await findExistingFormByTemplate(
+          db,
+          appointmentId,
+          templateRef.templateId,
+          isUserForm
+        );
+        
+        if (existingForm) {
+          console.log(
+            `[FormInit] Found existing shared form ${existingForm.id} (template: ${template.id}) for appointment ${appointmentId}. Reusing instead of creating duplicate.`
+          );
+          
+          // Reuse existing form - add to linkedForms but don't create new document
+          // Note: We still add it to allLinkedFormIds to ensure it's tracked,
+          // but we don't add it again if it's already in the appointment's linkedForms
+          // (This will be handled by the caller merging the arrays)
+          
+          const linkedForm: LinkedFormInfo = {
+            formId: existingForm.id,
+            templateId: template.id,
+            templateVersion: template.version,
+            title: template.title,
+            isUserForm: isUserForm,
+            isRequired: isRequired,
+            sortingOrder: templateRef.sortingOrder,
+            status: existingForm.status || FilledDocumentStatus.PENDING,
+            path: `${APPOINTMENTS_COLLECTION}/${appointmentId}/${formSubcollectionPath}/${existingForm.id}`,
+          };
+          initializedFormsInfo.push(linkedForm);
+          
+          // Add to allLinkedFormIds if not already present (to avoid duplicates)
+          if (!allLinkedFormIds.includes(existingForm.id)) {
+            allLinkedFormIds.push(existingForm.id);
+          }
+          
+          // Add to pendingUserFormsIds if it's a required user form and not already completed
+          if (isUserForm && isRequired && existingForm.status === FilledDocumentStatus.PENDING) {
+            if (!pendingUserFormsIds.includes(existingForm.id)) {
+              pendingUserFormsIds.push(existingForm.id);
+            }
+          }
+          
+          continue; // Skip creating new form, reuse existing one
+        }
+      } catch (error) {
+        console.warn(
+          `[FormInit] Error checking for existing form (template: ${templateRef.templateId}):`,
+          error
+        );
+        // Continue to create new form if check fails
+      }
+    }
+
+    // Create new form document (either procedure-specific or general form not found)
     const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
     const formsCollectionRef = collection(appointmentRef, formSubcollectionPath);
     
@@ -118,6 +268,9 @@ export async function initializeFormsForExtendedProcedure(
       const docRef = await addDoc(formsCollectionRef, filledDocumentData);
       const filledDocumentId = docRef.id;
 
+      // Update the document to include the id field in the data (for consistency)
+      await updateDoc(docRef, { id: filledDocumentId });
+
       // Add to pendingUserFormsIds if it's a required user form
       if (isUserForm && isRequired) {
         pendingUserFormsIds.push(filledDocumentId);
@@ -138,8 +291,9 @@ export async function initializeFormsForExtendedProcedure(
       };
       initializedFormsInfo.push(linkedForm);
 
+      const formType = isProcedureSpecific ? 'procedure-specific' : 'general/shared';
       console.log(
-        `[FormInit] Created FilledDocument ${filledDocumentId} (template: ${template.id}, isUserForm: ${isUserForm}) for extended procedure ${procedureId} in appointment ${appointmentId}.`
+        `[FormInit] Created ${formType} FilledDocument ${filledDocumentId} (template: ${template.id}, isUserForm: ${isUserForm}) for extended procedure ${procedureId} in appointment ${appointmentId}.`
       );
     } catch (error) {
       console.error(
@@ -154,6 +308,7 @@ export async function initializeFormsForExtendedProcedure(
 
 /**
  * Removes all forms associated with a specific procedure from an appointment
+ * Only removes procedure-specific forms. Shared forms are kept if still referenced by other procedures.
  * Removes both user forms and doctor forms
  * @param db Firestore instance
  * @param appointmentId Appointment ID
@@ -167,7 +322,34 @@ export async function removeFormsForExtendedProcedure(
 ): Promise<string[]> {
   const removedFormIds: string[] = [];
 
+  // Get appointment to check linkedForms
   const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  const appointmentSnap = await getDoc(appointmentRef);
+  
+  if (!appointmentSnap.exists()) {
+    console.warn(
+      `[FormInit] Appointment ${appointmentId} not found when removing forms for procedure ${procedureId}.`
+    );
+    return removedFormIds;
+  }
+
+  const appointment = appointmentSnap.data() as any;
+  const linkedForms = appointment.linkedForms || [];
+  
+  // Get all procedure IDs (main + extended) to check if shared forms are still referenced
+  const mainProcedureId = appointment.procedureId;
+  const extendedProcedureIds = appointment.metadata?.extendedProcedures?.map(
+    (ep: any) => ep.procedureId
+  ) || [];
+  const allProcedureIds = [mainProcedureId, ...extendedProcedureIds].filter(Boolean);
+  const remainingProcedureIds = allProcedureIds.filter((id: string) => id !== procedureId);
+
+  // Helper function to check if form appears multiple times in linkedForms (indicating it's shared)
+  const isFormSharedAndReferenced = (formId: string): boolean => {
+    const formEntries = linkedForms.filter((form: LinkedFormInfo) => form.formId === formId);
+    // If form appears multiple times in linkedForms, it's shared across procedures
+    return formEntries.length > 1;
+  };
 
   // Remove from doctor forms subcollection
   const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
@@ -179,11 +361,49 @@ export async function removeFormsForExtendedProcedure(
 
   for (const formDoc of doctorFormsSnap.docs) {
     try {
-      await deleteDoc(formDoc.ref);
-      removedFormIds.push(formDoc.id);
-      console.log(
-        `[FormInit] Removed doctor form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
-      );
+      const formData = formDoc.data() as FilledDocument;
+      
+      // Fetch template to check if form is shared
+      let isShared = false;
+      if (formData.templateId) {
+        try {
+          const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, formData.templateId);
+          const templateSnap = await getDoc(templateDoc);
+          if (templateSnap.exists()) {
+            const template = templateSnap.data() as DocumentTemplate;
+            isShared = !isProcedureSpecificForm(template);
+          }
+        } catch (error) {
+          console.warn(
+            `[FormInit] Could not check template for form ${formDoc.id}, assuming procedure-specific:`,
+            error
+          );
+        }
+      }
+
+      // Only delete procedure-specific forms
+      // Shared forms are kept even if procedureId matches, as they may be used by other procedures
+      if (!isShared) {
+        await deleteDoc(formDoc.ref);
+        removedFormIds.push(formDoc.id);
+        console.log(
+          `[FormInit] Removed procedure-specific doctor form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
+        );
+      } else {
+        // Check if form is still referenced by other procedures (appears multiple times in linkedForms)
+        if (isFormSharedAndReferenced(formDoc.id)) {
+          console.log(
+            `[FormInit] Skipped deletion of shared doctor form ${formDoc.id} - still referenced by other procedures.`
+          );
+        } else {
+          // Shared form but only referenced by this procedure (shouldn't happen, but handle it)
+          await deleteDoc(formDoc.ref);
+          removedFormIds.push(formDoc.id);
+          console.log(
+            `[FormInit] Removed shared doctor form ${formDoc.id} - no longer referenced by other procedures.`
+          );
+        }
+      }
     } catch (error) {
       console.error(
         `[FormInit] Error removing doctor form ${formDoc.id}:`,
@@ -202,11 +422,49 @@ export async function removeFormsForExtendedProcedure(
 
   for (const formDoc of userFormsSnap.docs) {
     try {
-      await deleteDoc(formDoc.ref);
-      removedFormIds.push(formDoc.id);
-      console.log(
-        `[FormInit] Removed user form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
-      );
+      const formData = formDoc.data() as FilledDocument;
+      
+      // Fetch template to check if form is shared
+      let isShared = false;
+      if (formData.templateId) {
+        try {
+          const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, formData.templateId);
+          const templateSnap = await getDoc(templateDoc);
+          if (templateSnap.exists()) {
+            const template = templateSnap.data() as DocumentTemplate;
+            isShared = !isProcedureSpecificForm(template);
+          }
+        } catch (error) {
+          console.warn(
+            `[FormInit] Could not check template for form ${formDoc.id}, assuming procedure-specific:`,
+            error
+          );
+        }
+      }
+
+      // Only delete procedure-specific forms
+      // Shared forms are kept even if procedureId matches, as they may be used by other procedures
+      if (!isShared) {
+        await deleteDoc(formDoc.ref);
+        removedFormIds.push(formDoc.id);
+        console.log(
+          `[FormInit] Removed procedure-specific user form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
+        );
+      } else {
+        // Check if form is still referenced by other procedures (appears multiple times in linkedForms)
+        if (isFormSharedAndReferenced(formDoc.id)) {
+          console.log(
+            `[FormInit] Skipped deletion of shared user form ${formDoc.id} - still referenced by other procedures.`
+          );
+        } else {
+          // Shared form but only referenced by this procedure (shouldn't happen, but handle it)
+          await deleteDoc(formDoc.ref);
+          removedFormIds.push(formDoc.id);
+          console.log(
+            `[FormInit] Removed shared user form ${formDoc.id} - no longer referenced by other procedures.`
+          );
+        }
+      }
     } catch (error) {
       console.error(
         `[FormInit] Error removing user form ${formDoc.id}:`,

package/src/services/documentation-templates/filled-document.service.ts

@@ -144,7 +144,12 @@ export class FilledDocumentService extends BaseService {
     if (!docSnap.exists()) {
       return null;
     }
-    return docSnap.data() as FilledDocument;
+    const data = docSnap.data() as FilledDocument;
+    // Ensure id is populated from Firestore document ID if not in data
+    if (!data.id) {
+      data.id = docSnap.id;
+    }
+    return data;
   }
 
   /**
@@ -287,9 +292,14 @@ export class FilledDocumentService extends BaseService {
     const documents: FilledDocument[] = [];
     let lastVisible: QueryDocumentSnapshot<FilledDocument> | null = null;
 
-    querySnapshot.forEach((doc) => {
-      documents.push(doc.data() as FilledDocument);
-      lastVisible = doc as QueryDocumentSnapshot<FilledDocument>;
+    querySnapshot.forEach((docSnapshot) => {
+      const data = docSnapshot.data() as FilledDocument;
+      // Ensure id is populated from Firestore document ID if not in data
+      if (!data.id) {
+        data.id = docSnapshot.id;
+      }
+      documents.push(data);
+      lastVisible = docSnapshot as QueryDocumentSnapshot<FilledDocument>;
     });
 
     return {