@blackcode_sa/metaestetics-api 1.12.46 → 1.12.48

package/src/services/appointment/utils/extended-procedure.utils.ts

@@ -7,7 +7,10 @@ import {
 } from '../../../types/appointment';
 import { getAppointmentOrThrow, initializeMetadata } from './zone-management.utils';
 import { PROCEDURES_COLLECTION } from '../../../types/procedure';
-import { initializeFormsForExtendedProcedure, removeFormsForExtendedProcedure } from './form-initialization.utils';
+import {
+  initializeFormsForExtendedProcedure,
+  removeFormsForExtendedProcedure,
+} from './form-initialization.utils';
 
 /**
  * Aggregates products from a procedure into appointmentProducts
@@ -19,7 +22,7 @@ import { initializeFormsForExtendedProcedure, removeFormsForExtendedProcedure }
 async function aggregateProductsFromProcedure(
   db: Firestore,
   procedureId: string,
-  existingProducts: AppointmentProductMetadata[]
+  existingProducts: AppointmentProductMetadata[],
 ): Promise<AppointmentProductMetadata[]> {
   const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
   const procedureSnap = await getDoc(procedureRef);
@@ -34,21 +37,24 @@ async function aggregateProductsFromProcedure(
   const productsMetadata = procedureData.productsMetadata || [];
 
   // Map procedure products to AppointmentProductMetadata
-  const newProducts: AppointmentProductMetadata[] = productsMetadata.map((pp: any) => {
-    // Each item in productsMetadata is a ProcedureProduct with embedded Product
-    const product = pp.product;
-    
-    return {
-      productId: product.id,
-      productName: product.name,
-      brandId: product.brandId,
-      brandName: product.brandName,
-      procedureId: procedureId,
-      price: pp.price,                    // Price from ProcedureProduct
-      currency: pp.currency,              // Currency from ProcedureProduct
-      unitOfMeasurement: pp.pricingMeasure, // PricingMeasure from ProcedureProduct
-    };
-  });
+  // Filter out any entries without products (safety check for product-free procedures like consultations)
+  const newProducts: AppointmentProductMetadata[] = productsMetadata
+    .filter((pp: any) => pp && pp.product)
+    .map((pp: any) => {
+      // Each item in productsMetadata is a ProcedureProduct with embedded Product
+      const product = pp.product;
+
+      return {
+        productId: product.id,
+        productName: product.name,
+        brandId: product.brandId,
+        brandName: product.brandName,
+        procedureId: procedureId,
+        price: pp.price, // Price from ProcedureProduct
+        currency: pp.currency, // Currency from ProcedureProduct
+        unitOfMeasurement: pp.pricingMeasure, // PricingMeasure from ProcedureProduct
+      };
+    });
 
   // Merge with existing products, avoiding duplicates
   const productMap = new Map<string, AppointmentProductMetadata>();
@@ -78,7 +84,7 @@ async function aggregateProductsFromProcedure(
  */
 async function createExtendedProcedureInfo(
   db: Firestore,
-  procedureId: string
+  procedureId: string,
 ): Promise<ExtendedProcedureInfo> {
   const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
   const procedureSnap = await getDoc(procedureRef);
@@ -92,19 +98,21 @@ async function createExtendedProcedureInfo(
   return {
     procedureId: procedureId,
     procedureName: data.name,
-    procedureFamily: data.family,                    // Use embedded family object
-    procedureCategoryId: data.category.id,           // Access embedded category
-    procedureCategoryName: data.category.name,       // Access embedded category
-    procedureSubCategoryId: data.subcategory.id,    // Access embedded subcategory
+    procedureFamily: data.family, // Use embedded family object
+    procedureCategoryId: data.category.id, // Access embedded category
+    procedureCategoryName: data.category.name, // Access embedded category
+    procedureSubCategoryId: data.subcategory.id, // Access embedded subcategory
     procedureSubCategoryName: data.subcategory.name, // Access embedded subcategory
-    procedureTechnologyId: data.technology.id,     // Access embedded technology
-    procedureTechnologyName: data.technology.name,  // Access embedded technology
-    procedureProducts: (data.productsMetadata || []).map((pp: any) => ({
-      productId: pp.product.id,                     // Access embedded product
-      productName: pp.product.name,                  // Access embedded product
-      brandId: pp.product.brandId,                   // Access embedded product
-      brandName: pp.product.brandName,                // Access embedded product
-    })),
+    procedureTechnologyId: data.technology.id, // Access embedded technology
+    procedureTechnologyName: data.technology.name, // Access embedded technology
+    procedureProducts: (data.productsMetadata || [])
+      .filter((pp: any) => pp && pp.product) // Safety check for product-free procedures
+      .map((pp: any) => ({
+        productId: pp.product.id, // Access embedded product
+        productName: pp.product.name, // Access embedded product
+        brandId: pp.product.brandId, // Access embedded product
+        brandName: pp.product.brandName, // Access embedded product
+      })),
   };
 }
 
@@ -119,15 +127,13 @@ async function createExtendedProcedureInfo(
 export async function addExtendedProcedureUtil(
   db: Firestore,
   appointmentId: string,
-  procedureId: string
+  procedureId: string,
 ): Promise<Appointment> {
   const appointment = await getAppointmentOrThrow(db, appointmentId);
   const metadata = initializeMetadata(appointment);
 
   // Check if procedure is already added
-  const existingProcedure = metadata.extendedProcedures?.find(
-    p => p.procedureId === procedureId
-  );
+  const existingProcedure = metadata.extendedProcedures?.find(p => p.procedureId === procedureId);
   if (existingProcedure) {
     throw new Error(`Procedure ${procedureId} is already added to this appointment`);
   }
@@ -138,18 +144,18 @@ export async function addExtendedProcedureUtil(
   // Get procedure data for forms and products
   const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
   const procedureSnap = await getDoc(procedureRef);
-  
+
   if (!procedureSnap.exists()) {
     throw new Error(`Procedure with ID ${procedureId} not found`);
   }
-  
+
   const procedureData = procedureSnap.data();
 
   // Aggregate products
   const updatedProducts = await aggregateProductsFromProcedure(
     db,
     procedureId,
-    metadata.appointmentProducts || []
+    metadata.appointmentProducts || [],
   );
 
   // Initialize forms for extended procedure
@@ -165,13 +171,16 @@ export async function addExtendedProcedureUtil(
       procedureData.documentationTemplates,
       appointment.patientId,
       appointment.practitionerId,
-      appointment.clinicBranchId
+      appointment.clinicBranchId,
     );
 
     // Merge form IDs and info
     updatedLinkedFormIds = [...updatedLinkedFormIds, ...formInitResult.allLinkedFormIds];
     updatedLinkedForms = [...updatedLinkedForms, ...formInitResult.initializedFormsInfo];
-    updatedPendingUserFormsIds = [...updatedPendingUserFormsIds, ...formInitResult.pendingUserFormsIds];
+    updatedPendingUserFormsIds = [
+      ...updatedPendingUserFormsIds,
+      ...formInitResult.pendingUserFormsIds,
+    ];
   }
 
   // Add extended procedure
@@ -193,7 +202,10 @@ export async function addExtendedProcedureUtil(
 
 /**
  * Removes an extended procedure from an appointment
- * Also removes associated products from appointmentProducts
+ * Also removes:
+ * - Associated products from appointmentProducts
+ * - Associated products from zonesData (all zones)
+ * - Associated forms
  * @param db Firestore instance
  * @param appointmentId Appointment ID
  * @param procedureId Procedure ID to remove
@@ -202,7 +214,7 @@ export async function addExtendedProcedureUtil(
 export async function removeExtendedProcedureUtil(
   db: Firestore,
   appointmentId: string,
-  procedureId: string
+  procedureId: string,
 ): Promise<Appointment> {
   const appointment = await getAppointmentOrThrow(db, appointmentId);
   const metadata = initializeMetadata(appointment);
@@ -212,9 +224,7 @@ export async function removeExtendedProcedureUtil(
   }
 
   // Find and remove the procedure
-  const procedureIndex = metadata.extendedProcedures.findIndex(
-    p => p.procedureId === procedureId
-  );
+  const procedureIndex = metadata.extendedProcedures.findIndex(p => p.procedureId === procedureId);
   if (procedureIndex === -1) {
     throw new Error(`Extended procedure ${procedureId} not found in this appointment`);
   }
@@ -222,23 +232,42 @@ export async function removeExtendedProcedureUtil(
   // Remove procedure
   metadata.extendedProcedures.splice(procedureIndex, 1);
 
-  // Remove products associated with this procedure
+  // Remove products associated with this procedure from appointmentProducts
   const updatedProducts = (metadata.appointmentProducts || []).filter(
-    p => p.procedureId !== procedureId
+    p => p.procedureId !== procedureId,
+  );
+
+  // Remove products from zonesData that belong to this procedure
+  const updatedZonesData = { ...(metadata.zonesData || {}) };
+  let productsRemovedFromZones = 0;
+
+  Object.keys(updatedZonesData).forEach(zoneId => {
+    const originalLength = updatedZonesData[zoneId].length;
+    updatedZonesData[zoneId] = updatedZonesData[zoneId].filter(item => {
+      // Keep notes and items that don't belong to this procedure
+      if (item.type === 'note') return true;
+      if (item.type === 'item' && item.belongingProcedureId !== procedureId) return true;
+      return false;
+    });
+    productsRemovedFromZones += originalLength - updatedZonesData[zoneId].length;
+  });
+
+  console.log(
+    `🗑️ [removeExtendedProcedure] Removed ${productsRemovedFromZones} products from zones for procedure ${procedureId}`,
   );
 
   // Remove forms associated with this procedure
   const removedFormIds = await removeFormsForExtendedProcedure(db, appointmentId, procedureId);
-  
+
   // Update appointment form arrays
   const updatedLinkedFormIds = (appointment.linkedFormIds || []).filter(
-    formId => !removedFormIds.includes(formId)
+    formId => !removedFormIds.includes(formId),
   );
   const updatedLinkedForms = (appointment.linkedForms || []).filter(
-    form => !removedFormIds.includes(form.formId)
+    form => !removedFormIds.includes(form.formId),
   );
   const updatedPendingUserFormsIds = (appointment.pendingUserFormsIds || []).filter(
-    formId => !removedFormIds.includes(formId)
+    formId => !removedFormIds.includes(formId),
   );
 
   // Update appointment
@@ -246,6 +275,7 @@ export async function removeExtendedProcedureUtil(
   await updateDoc(appointmentRef, {
     'metadata.extendedProcedures': metadata.extendedProcedures,
     'metadata.appointmentProducts': updatedProducts,
+    'metadata.zonesData': updatedZonesData,
     linkedFormIds: updatedLinkedFormIds,
     linkedForms: updatedLinkedForms,
     pendingUserFormsIds: updatedPendingUserFormsIds,
@@ -263,7 +293,7 @@ export async function removeExtendedProcedureUtil(
  */
 export async function getExtendedProceduresUtil(
   db: Firestore,
-  appointmentId: string
+  appointmentId: string,
 ): Promise<ExtendedProcedureInfo[]> {
   const appointment = await getAppointmentOrThrow(db, appointmentId);
   return appointment.metadata?.extendedProcedures || [];
@@ -277,9 +307,8 @@ export async function getExtendedProceduresUtil(
  */
 export async function getAppointmentProductsUtil(
   db: Firestore,
-  appointmentId: string
+  appointmentId: string,
 ): Promise<AppointmentProductMetadata[]> {
   const appointment = await getAppointmentOrThrow(db, appointmentId);
   return appointment.metadata?.appointmentProducts || [];
 }
-

package/src/services/appointment/utils/recommended-procedure.utils.ts

@@ -38,12 +38,14 @@ async function createExtendedProcedureInfoForRecommended(
     procedureSubCategoryName: data.subcategory.name,
     procedureTechnologyId: data.technology.id,
     procedureTechnologyName: data.technology.name,
-    procedureProducts: (data.productsMetadata || []).map((pp: any) => ({
-      productId: pp.product.id,
-      productName: pp.product.name,
-      brandId: pp.product.brandId,
-      brandName: pp.product.brandName,
-    })),
+    procedureProducts: (data.productsMetadata || [])
+      .filter((pp: any) => pp && pp.product) // Safety check for product-free procedures
+      .map((pp: any) => ({
+        productId: pp.product.id,
+        productName: pp.product.name,
+        brandId: pp.product.brandId,
+        brandName: pp.product.brandName,
+      })),
   };
 }
 

package/src/services/practitioner/practitioner.service.ts

@@ -1553,7 +1553,7 @@ export class PractitionerService extends BaseService {
         }
       }
 
-      // Create procedure data for free consultation (without productId)
+      // Create procedure data for free consultation (without productId or productsMetadata)
       const consultationData: Omit<CreateProcedureData, "productId"> = {
         name: "Free Consultation",
         nameLower: "free consultation",
@@ -1566,15 +1566,7 @@ export class PractitionerService extends BaseService {
         price: 0,
         currency: Currency.EUR,
         pricingMeasure: PricingMeasure.PER_SESSION,
-        productsMetadata: [
-          {
-            productId: "free-consultation-product",
-            price: 0,
-            currency: Currency.EUR,
-            pricingMeasure: PricingMeasure.PER_SESSION,
-            isDefault: true,
-          },
-        ],
+        productsMetadata: undefined, // No products needed for consultations
         duration: 30, // 30 minutes consultation
         practitionerId: practitionerId,
         clinicBranchId: clinicId,

package/src/services/procedure/procedure.service.ts

@@ -143,7 +143,7 @@ export class ProcedureService extends BaseService {
 
   /**
    * Transforms validated procedure product data (with productId) to ProcedureProduct objects (with full product)
-   * @param productsMetadata Array of validated procedure product data
+   * @param productsMetadata Array of validated procedure product data (optional)
    * @param technologyId Technology ID to fetch products from
    * @returns Array of ProcedureProduct objects with full product information
    */
@@ -154,9 +154,14 @@ export class ProcedureService extends BaseService {
       currency: Currency;
       pricingMeasure: PricingMeasure;
       isDefault?: boolean;
-    }[],
+    }[] | undefined,
     technologyId: string,
   ): Promise<ProcedureProduct[]> {
+    // Return empty array if no products metadata provided (for product-free procedures like consultations)
+    if (!productsMetadata || productsMetadata.length === 0) {
+      return [];
+    }
+
     const transformedProducts: ProcedureProduct[] = [];
 
     for (const productData of productsMetadata) {
@@ -189,21 +194,41 @@ export class ProcedureService extends BaseService {
   async createProcedure(data: CreateProcedureData): Promise<Procedure> {
     const validatedData = createProcedureSchema.parse(data);
 
+    // Check if this is a product-free procedure (e.g., free consultation)
+    const isProductFree = !validatedData.productId;
+
     // Generate procedure ID first so we can use it for media uploads
     const procedureId = this.generateId();
 
-    // Get references to related entities (Category, Subcategory, Technology, Product)
-    const [category, subcategory, technology, product] = await Promise.all([
+    // Get references to related entities (Category, Subcategory, Technology, and optionally Product)
+    const baseEntitiesPromises = [
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
-      this.productService.getById(validatedData.technologyId, validatedData.productId),
-    ]);
+    ];
+
+    // Only fetch product if productId is provided
+    if (!isProductFree) {
+      baseEntitiesPromises.push(
+        this.productService.getById(validatedData.technologyId, validatedData.productId!)
+      );
+    }
 
-    if (!category || !subcategory || !technology || !product) {
+    const results = await Promise.all(baseEntitiesPromises);
+    const category = results[0] as Category | null;
+    const subcategory = results[1] as Subcategory | null;
+    const technology = results[2] as Technology | null;
+    const product = isProductFree ? undefined : ((results[3] as Product | null) || undefined);
+
+    if (!category || !subcategory || !technology) {
       throw new Error('One or more required base entities not found');
     }
 
+    // For regular procedures, validate product exists
+    if (!isProductFree && !product) {
+      throw new Error('Product not found for regular procedure');
+    }
+
     // Get clinic and practitioner information for aggregation
     const clinicRef = doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
     const clinicSnapshot = await getDoc(clinicRef);
@@ -333,23 +358,50 @@ export class ProcedureService extends BaseService {
       throw new Error('Practitioner IDs array cannot be empty.');
     }
 
+    // Check if this is a product-free procedure
+    const isProductFree = !baseData.productId;
+
     // Add a dummy practitionerId for the validation schema to pass
     const validationData = { ...baseData, practitionerId: practitionerIds[0] };
     const validatedData = createProcedureSchema.parse(validationData);
 
     // 2. Fetch common data once to avoid redundant reads
-    const [category, subcategory, technology, product, clinicSnapshot] = await Promise.all([
+    const baseEntitiesPromises = [
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
-      this.productService.getById(validatedData.technologyId, validatedData.productId),
-      getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId)),
+    ];
+
+    // Only fetch product if productId is provided
+    if (!isProductFree) {
+      baseEntitiesPromises.push(
+        this.productService.getById(validatedData.technologyId, validatedData.productId!)
+      );
+    }
+
+    // Fetch clinic separately to maintain type safety
+    const clinicSnapshotPromise = getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId));
+
+    const [baseResults, clinicSnapshot] = await Promise.all([
+      Promise.all(baseEntitiesPromises),
+      clinicSnapshotPromise
     ]);
+    
+    const category = baseResults[0] as Category | null;
+    const subcategory = baseResults[1] as Subcategory | null;
+    const technology = baseResults[2] as Technology | null;
+    const product = isProductFree ? undefined : ((baseResults[3] as Product | null) || undefined);
 
-    if (!category || !subcategory || !technology || !product) {
+    if (!category || !subcategory || !technology) {
       throw new Error('One or more required base entities not found');
     }
-    if (!clinicSnapshot.exists()) {
+    
+    // For regular procedures, validate product exists
+    if (!isProductFree && !product) {
+      throw new Error('Product not found for regular procedure');
+    }
+    
+    if (!clinicSnapshot || !clinicSnapshot.exists()) {
       throw new Error(`Clinic with ID ${validatedData.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data() as Clinic;
@@ -1416,6 +1468,7 @@ export class ProcedureService extends BaseService {
     }
 
     // Transform productsMetadata from validation format to ProcedureProduct format
+    // For consultations, this will return empty array since no products are provided
     const transformedProductsMetadata = await this.transformProductsMetadata(
       data.productsMetadata,
       data.technologyId,
@@ -1451,22 +1504,6 @@ export class ProcedureService extends BaseService {
       services: practitioner.procedures || [],
     };
 
-    // Create a placeholder product for consultation procedures
-    const consultationProduct: Product = {
-      id: 'consultation-no-product',
-      name: 'No Product Required',
-      description: 'Consultation procedures do not require specific products',
-      brandId: 'consultation-brand',
-      brandName: 'Consultation',
-      technologyId: data.technologyId,
-      technologyName: technology.name,
-      categoryId: technology.categoryId,
-      subcategoryId: technology.subcategoryId,
-      isActive: true,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
     // Create the procedure object
     const { productsMetadata: _, ...dataWithoutProductsMetadata } = data;
     const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
@@ -1477,8 +1514,8 @@ export class ProcedureService extends BaseService {
       category,
       subcategory,
       technology,
-      product: consultationProduct, // Use placeholder product
-      productsMetadata: transformedProductsMetadata, // Use transformed data, not original
+      product: undefined, // No product needed for consultations
+      productsMetadata: transformedProductsMetadata, // Empty array for consultations
       blockingConditions: technology.blockingConditions,
       contraindications: technology.contraindications || [],
       contraindicationIds: technology.contraindications?.map(c => c.id) || [],

package/src/types/procedure/index.ts

@@ -45,8 +45,8 @@ export interface Procedure {
   subcategory: Subcategory;
   /** Technology used in this procedure */
   technology: Technology;
-  /** Default product used in this procedure */
-  product: Product;
+  /** Default product used in this procedure (optional for consultations) */
+  product?: Product;
   /** Default price of the procedure */
   price: number;
   /** Currency for the price */
@@ -54,7 +54,7 @@ export interface Procedure {
   /** How the price is measured (per ml, per zone, etc.) - for default product*/
   pricingMeasure: PricingMeasure;
   /** Duration of the procedure in minutes */
-  productsMetadata: ProcedureProduct[];
+  productsMetadata?: ProcedureProduct[];
   duration: number;
   /** Blocking conditions that prevent this procedure */
   blockingConditions: BlockingCondition[];
@@ -104,9 +104,9 @@ export interface CreateProcedureData {
   categoryId: string;
   subcategoryId: string;
   technologyId: string;
-  productId: string;
+  productId?: string;
   price: number;
-  productsMetadata: {
+  productsMetadata?: {
     productId: string;
     price: number;
     currency: Currency;

package/src/validations/appointment.schema.ts

@@ -59,7 +59,7 @@ export const procedureExtendedInfoSchema = z.object({
       productName: z.string().min(MIN_STRING_LENGTH, 'Product name is required'),
       brandId: z.string().min(MIN_STRING_LENGTH, 'Brand ID is required'),
       brandName: z.string().min(MIN_STRING_LENGTH, 'Brand name is required'),
-    })
+    }),
   ),
 });
 
@@ -176,59 +176,66 @@ export const finalBillingSchema = z.object({
 /**
  * Schema for zone item data (product or note per zone)
  */
-export const zoneItemDataSchema = z.object({
-  productId: z.string().optional(),
-  productName: z.string().optional(),
-  productBrandId: z.string().optional(),
-  productBrandName: z.string().optional(),
-  belongingProcedureId: z.string().min(MIN_STRING_LENGTH, 'Belonging procedure ID is required'),
-  type: z.enum(['item', 'note'], {
-    required_error: 'Type must be either "item" or "note"',
-  }),
-  stage: z.enum(['before', 'after'], {
-    required_error: 'Stage must be either "before" or "after"',
-  }).optional(),
-  price: z.number().min(0, 'Price must be non-negative').optional(),
-  currency: z.nativeEnum(Currency).optional(),
-  unitOfMeasurement: z.nativeEnum(PricingMeasure).optional(),
-  priceOverrideAmount: z.number().min(0, 'Price override amount must be non-negative').optional(),
-  quantity: z.number().min(0, 'Quantity must be non-negative').optional(),
-  parentZone: z.string().min(MIN_STRING_LENGTH, 'Parent zone is required').refine(
-    val => {
-      const parts = val.split('.');
-      return parts.length === 2;
+export const zoneItemDataSchema = z
+  .object({
+    productId: z.string().optional(),
+    productName: z.string().optional(),
+    productBrandId: z.string().optional(),
+    productBrandName: z.string().optional(),
+    belongingProcedureId: z.string().min(MIN_STRING_LENGTH, 'Belonging procedure ID is required'),
+    type: z.enum(['item', 'note'], {
+      required_error: 'Type must be either "item" or "note"',
+    }),
+    stage: z
+      .enum(['before', 'after'], {
+        required_error: 'Stage must be either "before" or "after"',
+      })
+      .optional(),
+    price: z.number().min(0, 'Price must be non-negative').optional(),
+    currency: z.nativeEnum(Currency).optional(),
+    unitOfMeasurement: z.nativeEnum(PricingMeasure).optional(),
+    priceOverrideAmount: z.number().min(0, 'Price override amount must be non-negative').optional(),
+    quantity: z.number().min(0, 'Quantity must be non-negative').optional(),
+    parentZone: z
+      .string()
+      .min(MIN_STRING_LENGTH, 'Parent zone is required')
+      .refine(
+        val => {
+          const parts = val.split('.');
+          return parts.length === 2;
+        },
+        {
+          message: 'Parent zone must be in "category.zone" format (e.g., "face.forehead")',
+        },
+      ),
+    subzones: z.array(z.string()).refine(
+      val => {
+        return val.every(subzone => {
+          const parts = subzone.split('.');
+          return parts.length === 3;
+        });
+      },
+      {
+        message: 'Subzones must be in "category.zone.subzone" format (e.g., "face.forehead.left")',
+      },
+    ),
+    notes: z.string().max(MAX_STRING_LENGTH_LONG, 'Notes too long').optional(),
+    subtotal: z.number().min(0, 'Subtotal must be non-negative').optional(),
+    ionNumber: z.string().optional(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+  })
+  .refine(
+    data => {
+      if (data.type === 'item') {
+        return !!(data.productId && data.productName && (data.price || data.priceOverrideAmount));
+      }
+      return true;
     },
     {
-      message: 'Parent zone must be in "category.zone" format (e.g., "face.forehead")',
-    }
-  ),
-  subzones: z.array(z.string()).refine(
-    val => {
-      return val.every(subzone => {
-        const parts = subzone.split('.');
-        return parts.length === 3;
-      });
+      message: 'Item type requires productId, productName, and either price or priceOverrideAmount',
     },
-    {
-      message: 'Subzones must be in "category.zone.subzone" format (e.g., "face.forehead.left")',
-    }
-  ),
-  notes: z.string().max(MAX_STRING_LENGTH_LONG, 'Notes too long').optional(),
-  subtotal: z.number().min(0, 'Subtotal must be non-negative').optional(),
-  ionNumber: z.string().optional(),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-}).refine(
-  data => {
-    if (data.type === 'item') {
-      return !!(data.productId && data.productName && (data.price || data.priceOverrideAmount));
-    }
-    return true;
-  },
-  {
-    message: 'Item type requires productId, productName, and either price or priceOverrideAmount',
-  }
-);
+  );
 
 /**
  * Schema for appointment product metadata
@@ -263,7 +270,7 @@ export const extendedProcedureInfoSchema = z.object({
       productName: z.string().min(MIN_STRING_LENGTH, 'Product name is required'),
       brandId: z.string().min(MIN_STRING_LENGTH, 'Brand ID is required'),
       brandName: z.string().min(MIN_STRING_LENGTH, 'Brand name is required'),
-    })
+    }),
   ),
 });
 
@@ -277,7 +284,7 @@ export const recommendedProcedureTimeframeSchema = z.object({
 
 export const recommendedProcedureSchema = z.object({
   procedure: extendedProcedureInfoSchema,
-  note: z.string().min(1, 'Note is required').max(MAX_STRING_LENGTH_LONG, 'Note too long'),
+  note: z.string().max(MAX_STRING_LENGTH_LONG, 'Note too long'), // Note is now optional (no min length)
   timeframe: recommendedProcedureTimeframeSchema,
 });