@blackcode_sa/metaestetics-api 1.12.40 → 1.12.42

package/dist/index.mjs

@@ -2236,7 +2236,7 @@ var AppointmentService = class extends BaseService {
    * @returns The updated appointment
    */
   async updateAppointment(appointmentId, data) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     try {
       console.log(`[APPOINTMENT_SERVICE] Updating appointment with ID: ${appointmentId}`);
       if ((_a = data.metadata) == null ? void 0 : _a.zonePhotos) {
@@ -2259,18 +2259,34 @@ var AppointmentService = class extends BaseService {
         }
         data.metadata.zonePhotos = migratedZonePhotos;
       }
-      if (((_b = data.metadata) == null ? void 0 : _b.recommendedProcedures) && Array.isArray(data.metadata.recommendedProcedures)) {
-        const validRecommendations = data.metadata.recommendedProcedures.filter(
-          (rec) => rec.note && typeof rec.note === "string" && rec.note.trim().length > 0
-        );
+      console.log(
+        "[APPOINTMENT_SERVICE] \u{1F50D} BEFORE CLEANUP - recommendedProcedures:",
+        JSON.stringify((_b = data.metadata) == null ? void 0 : _b.recommendedProcedures, null, 2)
+      );
+      if (((_c = data.metadata) == null ? void 0 : _c.recommendedProcedures) && Array.isArray(data.metadata.recommendedProcedures)) {
+        const validRecommendations = data.metadata.recommendedProcedures.filter((rec) => {
+          const isValid = rec.note && typeof rec.note === "string" && rec.note.trim().length > 0;
+          if (!isValid) {
+            console.log("[APPOINTMENT_SERVICE] \u274C INVALID recommendation found:", rec);
+          }
+          return isValid;
+        });
         if (validRecommendations.length !== data.metadata.recommendedProcedures.length) {
           console.log(
-            `[APPOINTMENT_SERVICE] Removing ${data.metadata.recommendedProcedures.length - validRecommendations.length} invalid recommended procedures with empty notes`
+            `[APPOINTMENT_SERVICE] \u{1F9F9} Removing ${data.metadata.recommendedProcedures.length - validRecommendations.length} invalid recommended procedures with empty notes`
           );
           data.metadata.recommendedProcedures = validRecommendations;
+        } else {
+          console.log("[APPOINTMENT_SERVICE] \u2705 All recommendedProcedures are valid");
         }
       }
+      console.log(
+        "[APPOINTMENT_SERVICE] \u{1F50D} AFTER CLEANUP - recommendedProcedures:",
+        JSON.stringify((_d = data.metadata) == null ? void 0 : _d.recommendedProcedures, null, 2)
+      );
+      console.log("[APPOINTMENT_SERVICE] \u{1F50D} Starting Zod validation...");
       const validatedData = await updateAppointmentSchema.parseAsync(data);
+      console.log("[APPOINTMENT_SERVICE] \u2705 Zod validation passed!");
       const updatedAppointment = await updateAppointmentUtil(this.db, appointmentId, validatedData);
       console.log(`[APPOINTMENT_SERVICE] Appointment ${appointmentId} updated successfully`);
       return updatedAppointment;
@@ -18943,8 +18959,14 @@ import {
   updateDoc as updateDoc38,
   where as where36,
   arrayUnion as arrayUnion9,
-  arrayRemove as arrayRemove8
+  arrayRemove as arrayRemove8,
+  writeBatch as writeBatch7
 } from "firebase/firestore";
+
+// src/backoffice/types/product.types.ts
+var PRODUCTS_COLLECTION = "products";
+
+// src/backoffice/services/technology.service.ts
 var DEFAULT_CERTIFICATION_REQUIREMENT = {
   minimumLevel: "aesthetician" /* AESTHETICIAN */,
   requiredSpecialties: []
@@ -19106,7 +19128,18 @@ var TechnologyService = class extends BaseService {
     });
     updateData.updatedAt = /* @__PURE__ */ new Date();
     const docRef = doc41(this.technologiesRef, id);
+    const beforeTech = await this.getById(id);
     await updateDoc38(docRef, updateData);
+    const categoryChanged = beforeTech && updateData.categoryId && beforeTech.categoryId !== updateData.categoryId;
+    const subcategoryChanged = beforeTech && updateData.subcategoryId && beforeTech.subcategoryId !== updateData.subcategoryId;
+    const nameChanged = beforeTech && updateData.name && beforeTech.name !== updateData.name;
+    if (categoryChanged || subcategoryChanged || nameChanged) {
+      await this.updateProductsInSubcollection(id, {
+        categoryId: updateData.categoryId,
+        subcategoryId: updateData.subcategoryId,
+        technologyName: updateData.name
+      });
+    }
     return this.getById(id);
   }
   /**
@@ -19542,6 +19575,125 @@ var TechnologyService = class extends BaseService {
       })
     );
   }
+  // ==========================================
+  // NEW METHODS: Product assignment management
+  // ==========================================
+  /**
+   * Assigns multiple products to a technology
+   * Updates each product's assignedTechnologyIds array
+   */
+  async assignProducts(technologyId, productIds) {
+    const batch = writeBatch7(this.db);
+    for (const productId of productIds) {
+      const productRef = doc41(this.db, PRODUCTS_COLLECTION, productId);
+      batch.update(productRef, {
+        assignedTechnologyIds: arrayUnion9(technologyId),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    await batch.commit();
+  }
+  /**
+   * Unassigns multiple products from a technology
+   * Updates each product's assignedTechnologyIds array
+   */
+  async unassignProducts(technologyId, productIds) {
+    const batch = writeBatch7(this.db);
+    for (const productId of productIds) {
+      const productRef = doc41(this.db, PRODUCTS_COLLECTION, productId);
+      batch.update(productRef, {
+        assignedTechnologyIds: arrayRemove8(technologyId),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    await batch.commit();
+  }
+  /**
+   * Gets products assigned to a specific technology
+   * Reads from top-level collection for immediate consistency (Cloud Functions may lag)
+   */
+  async getAssignedProducts(technologyId) {
+    const q = query36(
+      collection36(this.db, PRODUCTS_COLLECTION),
+      where36("assignedTechnologyIds", "array-contains", technologyId),
+      where36("isActive", "==", true),
+      orderBy22("name")
+    );
+    const snapshot = await getDocs36(q);
+    return snapshot.docs.map(
+      (doc44) => ({
+        id: doc44.id,
+        ...doc44.data()
+      })
+    );
+  }
+  /**
+   * Gets products NOT assigned to a specific technology
+   */
+  async getUnassignedProducts(technologyId) {
+    const q = query36(
+      collection36(this.db, PRODUCTS_COLLECTION),
+      where36("isActive", "==", true),
+      orderBy22("name")
+    );
+    const snapshot = await getDocs36(q);
+    const allProducts = snapshot.docs.map(
+      (doc44) => ({
+        id: doc44.id,
+        ...doc44.data()
+      })
+    );
+    return allProducts.filter(
+      (product) => {
+        var _a;
+        return !((_a = product.assignedTechnologyIds) == null ? void 0 : _a.includes(technologyId));
+      }
+    );
+  }
+  /**
+   * Gets product assignment statistics for a technology
+   */
+  async getProductStats(technologyId) {
+    const products = await this.getAssignedProducts(technologyId);
+    const byBrand = {};
+    products.forEach((product) => {
+      byBrand[product.brandName] = (byBrand[product.brandName] || 0) + 1;
+    });
+    return {
+      totalAssigned: products.length,
+      byBrand
+    };
+  }
+  /**
+   * Updates products in technology subcollection when technology metadata changes
+   * @param technologyId - ID of the technology
+   * @param updates - Fields to update (categoryId, subcategoryId, technologyName)
+   */
+  async updateProductsInSubcollection(technologyId, updates) {
+    const productsRef = collection36(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
+    const productsSnapshot = await getDocs36(productsRef);
+    if (productsSnapshot.empty) {
+      return;
+    }
+    const batch = writeBatch7(this.db);
+    for (const productDoc of productsSnapshot.docs) {
+      const productRef = productDoc.ref;
+      const updateFields = {};
+      if (updates.categoryId !== void 0) {
+        updateFields.categoryId = updates.categoryId;
+      }
+      if (updates.subcategoryId !== void 0) {
+        updateFields.subcategoryId = updates.subcategoryId;
+      }
+      if (updates.technologyName !== void 0) {
+        updateFields.technologyName = updates.technologyName;
+      }
+      if (Object.keys(updateFields).length > 0) {
+        batch.update(productRef, updateFields);
+      }
+    }
+    await batch.commit();
+  }
 };
 
 // src/backoffice/services/product.service.ts
@@ -19558,16 +19710,20 @@ import {
   limit as limit21,
   orderBy as orderBy23,
   startAfter as startAfter19,
-  getCountFromServer as getCountFromServer7
+  getCountFromServer as getCountFromServer7,
+  arrayUnion as arrayUnion10,
+  arrayRemove as arrayRemove9
 } from "firebase/firestore";
-
-// src/backoffice/types/product.types.ts
-var PRODUCTS_COLLECTION = "products";
-
-// src/backoffice/services/product.service.ts
 var ProductService = class extends BaseService {
   /**
-   * Gets reference to products collection under a technology
+   * Gets reference to top-level products collection (source of truth)
+   * @returns Firestore collection reference
+   */
+  getTopLevelProductsRef() {
+    return collection37(this.db, PRODUCTS_COLLECTION);
+  }
+  /**
+   * Gets reference to products collection under a technology (backward compatibility)
    * @param technologyId - ID of the technology
    * @returns Firestore collection reference
    */
@@ -19583,6 +19739,7 @@ var ProductService = class extends BaseService {
       ...product,
       brandId,
       technologyId,
+      // Required for old subcollection structure
       createdAt: now,
       updatedAt: now,
       isActive: true
@@ -19642,30 +19799,26 @@ var ProductService = class extends BaseService {
   }
   /**
    * Gets counts of active products grouped by category, subcategory, and technology.
-   * This uses a single collectionGroup query for efficiency.
+   * Queries technology subcollections which have the legacy fields synced by Cloud Functions.
    */
   async getProductCounts() {
-    const q = query37(collectionGroup3(this.db, PRODUCTS_COLLECTION), where37("isActive", "==", true));
-    const snapshot = await getDocs37(q);
     const counts = {
       byCategory: {},
       bySubcategory: {},
       byTechnology: {}
     };
-    if (snapshot.empty) {
-      return counts;
-    }
+    const q = query37(collectionGroup3(this.db, PRODUCTS_COLLECTION), where37("isActive", "==", true));
+    const snapshot = await getDocs37(q);
     snapshot.docs.forEach((doc44) => {
       const product = doc44.data();
-      const { categoryId, subcategoryId, technologyId } = product;
-      if (categoryId) {
-        counts.byCategory[categoryId] = (counts.byCategory[categoryId] || 0) + 1;
+      if (product.categoryId) {
+        counts.byCategory[product.categoryId] = (counts.byCategory[product.categoryId] || 0) + 1;
       }
-      if (subcategoryId) {
-        counts.bySubcategory[subcategoryId] = (counts.bySubcategory[subcategoryId] || 0) + 1;
+      if (product.subcategoryId) {
+        counts.bySubcategory[product.subcategoryId] = (counts.bySubcategory[product.subcategoryId] || 0) + 1;
       }
-      if (technologyId) {
-        counts.byTechnology[technologyId] = (counts.byTechnology[technologyId] || 0) + 1;
+      if (product.technologyId) {
+        counts.byTechnology[product.technologyId] = (counts.byTechnology[product.technologyId] || 0) + 1;
       }
     });
     return counts;
@@ -19744,12 +19897,166 @@ var ProductService = class extends BaseService {
       ...docSnap.data()
     };
   }
+  // ==========================================
+  // NEW METHODS: Top-level collection (preferred)
+  // ==========================================
+  /**
+   * Creates a new product in the top-level collection
+   */
+  async createTopLevel(brandId, product, technologyIds = []) {
+    const now = /* @__PURE__ */ new Date();
+    const newProduct = {
+      ...product,
+      brandId,
+      assignedTechnologyIds: technologyIds,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true
+    };
+    const productRef = await addDoc8(this.getTopLevelProductsRef(), newProduct);
+    return { id: productRef.id, ...newProduct };
+  }
+  /**
+   * Gets all products from the top-level collection
+   */
+  async getAllTopLevel(options) {
+    const { rowsPerPage, lastVisible, brandId } = options;
+    const constraints = [where37("isActive", "==", true), orderBy23("name")];
+    if (brandId) {
+      constraints.push(where37("brandId", "==", brandId));
+    }
+    if (lastVisible) {
+      constraints.push(startAfter19(lastVisible));
+    }
+    constraints.push(limit21(rowsPerPage));
+    const q = query37(this.getTopLevelProductsRef(), ...constraints);
+    const snapshot = await getDocs37(q);
+    const products = snapshot.docs.map(
+      (doc44) => ({
+        id: doc44.id,
+        ...doc44.data()
+      })
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { products, lastVisible: newLastVisible };
+  }
+  /**
+   * Gets a product by ID from the top-level collection
+   */
+  async getByIdTopLevel(productId) {
+    const docRef = doc42(this.getTopLevelProductsRef(), productId);
+    const docSnap = await getDoc43(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data()
+    };
+  }
+  /**
+   * Updates a product in the top-level collection
+   */
+  async updateTopLevel(productId, product) {
+    const updateData = {
+      ...product,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const docRef = doc42(this.getTopLevelProductsRef(), productId);
+    await updateDoc39(docRef, updateData);
+    return this.getByIdTopLevel(productId);
+  }
+  /**
+   * Deletes a product from the top-level collection (soft delete)
+   */
+  async deleteTopLevel(productId) {
+    await this.updateTopLevel(productId, {
+      isActive: false
+    });
+  }
+  /**
+   * Assigns a product to a technology
+   */
+  async assignToTechnology(productId, technologyId) {
+    const docRef = doc42(this.getTopLevelProductsRef(), productId);
+    await updateDoc39(docRef, {
+      assignedTechnologyIds: arrayUnion10(technologyId),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Unassigns a product from a technology
+   */
+  async unassignFromTechnology(productId, technologyId) {
+    const docRef = doc42(this.getTopLevelProductsRef(), productId);
+    await updateDoc39(docRef, {
+      assignedTechnologyIds: arrayRemove9(technologyId),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Gets products assigned to a specific technology
+   */
+  async getAssignedProducts(technologyId) {
+    const q = query37(
+      this.getTopLevelProductsRef(),
+      where37("assignedTechnologyIds", "array-contains", technologyId),
+      where37("isActive", "==", true),
+      orderBy23("name")
+    );
+    const snapshot = await getDocs37(q);
+    return snapshot.docs.map(
+      (doc44) => ({
+        id: doc44.id,
+        ...doc44.data()
+      })
+    );
+  }
+  /**
+   * Gets products NOT assigned to a specific technology
+   */
+  async getUnassignedProducts(technologyId) {
+    const q = query37(
+      this.getTopLevelProductsRef(),
+      where37("isActive", "==", true),
+      orderBy23("name")
+    );
+    const snapshot = await getDocs37(q);
+    const allProducts = snapshot.docs.map(
+      (doc44) => ({
+        id: doc44.id,
+        ...doc44.data()
+      })
+    );
+    return allProducts.filter(
+      (product) => {
+        var _a;
+        return !((_a = product.assignedTechnologyIds) == null ? void 0 : _a.includes(technologyId));
+      }
+    );
+  }
+  /**
+   * Gets all products for a brand (from top-level collection)
+   */
+  async getByBrand(brandId) {
+    const q = query37(
+      this.getTopLevelProductsRef(),
+      where37("brandId", "==", brandId),
+      where37("isActive", "==", true),
+      orderBy23("name")
+    );
+    const snapshot = await getDocs37(q);
+    return snapshot.docs.map(
+      (doc44) => ({
+        id: doc44.id,
+        ...doc44.data()
+      })
+    );
+  }
 };
 
 // src/backoffice/services/constants.service.ts
 import {
-  arrayRemove as arrayRemove9,
-  arrayUnion as arrayUnion10,
+  arrayRemove as arrayRemove10,
+  arrayUnion as arrayUnion11,
   doc as doc43,
   getDoc as getDoc44,
   setDoc as setDoc30,
@@ -19817,7 +20124,7 @@ var ConstantsService = class extends BaseService {
       await setDoc30(this.treatmentBenefitsDocRef, { benefits: [newBenefit] });
     } else {
       await updateDoc40(this.treatmentBenefitsDocRef, {
-        benefits: arrayUnion10(newBenefit)
+        benefits: arrayUnion11(newBenefit)
       });
     }
     return newBenefit;
@@ -19871,7 +20178,7 @@ var ConstantsService = class extends BaseService {
       return;
     }
     await updateDoc40(this.treatmentBenefitsDocRef, {
-      benefits: arrayRemove9(benefitToRemove)
+      benefits: arrayRemove10(benefitToRemove)
     });
   }
   // =================================================================
@@ -19924,7 +20231,7 @@ var ConstantsService = class extends BaseService {
       });
     } else {
       await updateDoc40(this.contraindicationsDocRef, {
-        contraindications: arrayUnion10(newContraindication)
+        contraindications: arrayUnion11(newContraindication)
       });
     }
     return newContraindication;
@@ -19980,7 +20287,7 @@ var ConstantsService = class extends BaseService {
       return;
     }
     await updateDoc40(this.contraindicationsDocRef, {
-      contraindications: arrayRemove9(toRemove)
+      contraindications: arrayRemove10(toRemove)
     });
   }
 };

package/package.json

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

package/src/backoffice/services/migrate-products.ts

@@ -0,0 +1,116 @@
+import * as admin from 'firebase-admin';
+import { Product } from '../types/product.types';
+
+/**
+ * Migration script to copy existing products from technology subcollections
+ * to the new top-level products collection
+ * 
+ * Usage: Run this once to migrate existing data
+ */
+export async function migrateProductsToTopLevel(db: admin.firestore.Firestore) {
+  console.log('🚀 Starting product migration...');
+  
+  // Get all technologies
+  const technologiesSnapshot = await db.collection('technologies').get();
+  
+  const productMap = new Map<string, {
+    product: any;
+    technologyIds: string[];
+  }>();
+  
+  let totalProcessed = 0;
+  
+  // Step 1: Collect all products from all technology subcollections
+  for (const techDoc of technologiesSnapshot.docs) {
+    const technologyId = techDoc.id;
+    console.log(`📦 Processing technology: ${technologyId}`);
+    
+    const productsSnapshot = await db
+      .collection('technologies')
+      .doc(technologyId)
+      .collection('products')
+      .get();
+    
+    for (const productDoc of productsSnapshot.docs) {
+      const productId = productDoc.id;
+      const productData = productDoc.data();
+      
+      totalProcessed++;
+      
+      // Deduplicate by name + brandId
+      const key = `${productData.name}_${productData.brandId}`;
+      
+      if (productMap.has(key)) {
+        // Product already exists, just add this technology
+        productMap.get(key)!.technologyIds.push(technologyId);
+      } else {
+        // New product
+        productMap.set(key, {
+          product: productData,
+          technologyIds: [technologyId],
+        });
+      }
+    }
+  }
+  
+  console.log(`✅ Found ${productMap.size} unique products from ${totalProcessed} total entries`);
+  
+  // Step 2: Create products in top-level collection
+  const batch = db.batch();
+  let batchCount = 0;
+  const MAX_BATCH_SIZE = 500;
+  let createdCount = 0;
+  
+  for (const [key, { product, technologyIds }] of productMap.entries()) {
+    const productRef = db.collection('products').doc();
+    
+    const migratedProduct: any = {
+      ...product,
+      assignedTechnologyIds: technologyIds, // Track all assigned technologies
+      migratedAt: admin.firestore.FieldValue.serverTimestamp(),
+      migrationKey: key, // For debugging
+    };
+    
+    batch.set(productRef, migratedProduct);
+    createdCount++;
+    batchCount++;
+    
+    if (batchCount >= MAX_BATCH_SIZE) {
+      await batch.commit();
+      console.log(`💾 Committed batch of ${batchCount} products (${createdCount}/${productMap.size})`);
+      batchCount = 0;
+    }
+  }
+  
+  if (batchCount > 0) {
+    await batch.commit();
+    console.log(`💾 Committed final batch of ${batchCount} products`);
+  }
+  
+  console.log('✅ Migration complete!');
+  console.log(`📊 Summary:`);
+  console.log(`   - Products processed: ${totalProcessed}`);
+  console.log(`   - Unique products created: ${createdCount}`);
+  console.log(`   - Average technologies per product: ${(createdCount > 0 ? totalProcessed / createdCount : 0).toFixed(2)}`);
+  
+  return {
+    totalProcessed,
+    uniqueCreated: createdCount,
+  };
+}
+
+/**
+ * Run migration (for testing)
+ */
+if (require.main === module) {
+  (async () => {
+    try {
+      await migrateProductsToTopLevel(admin.firestore());
+      process.exit(0);
+    } catch (error) {
+      console.error('❌ Migration failed:', error);
+      process.exit(1);
+    }
+  })();
+}
+