@blackcode_sa/metaestetics-api 1.12.46 → 1.12.47

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,6 +194,11 @@ export class ProcedureService extends BaseService {
   async createProcedure(data: CreateProcedureData): Promise<Procedure> {
     const validatedData = createProcedureSchema.parse(data);
 
+    // Validate that productId is provided (regular procedures require products)
+    if (!validatedData.productId) {
+      throw new Error('productId is required for regular procedures. Use createConsultationProcedure for product-free procedures.');
+    }
+
     // Generate procedure ID first so we can use it for media uploads
     const procedureId = this.generateId();
 
@@ -197,7 +207,7 @@ export class ProcedureService extends BaseService {
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
-      this.productService.getById(validatedData.technologyId, validatedData.productId),
+      this.productService.getById(validatedData.technologyId, validatedData.productId!), // Safe: validated above
     ]);
 
     if (!category || !subcategory || !technology || !product) {
@@ -333,6 +343,11 @@ export class ProcedureService extends BaseService {
       throw new Error('Practitioner IDs array cannot be empty.');
     }
 
+    // Validate that productId is provided (regular procedures require products)
+    if (!baseData.productId) {
+      throw new Error('productId is required for regular procedures. Use createConsultationProcedure for product-free procedures.');
+    }
+
     // Add a dummy practitionerId for the validation schema to pass
     const validationData = { ...baseData, practitionerId: practitionerIds[0] };
     const validatedData = createProcedureSchema.parse(validationData);
@@ -342,7 +357,7 @@ export class ProcedureService extends BaseService {
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
-      this.productService.getById(validatedData.technologyId, validatedData.productId),
+      this.productService.getById(validatedData.technologyId, validatedData.productId!), // Safe: validated above
       getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId)),
     ]);
 
@@ -1416,6 +1431,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 +1467,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 +1477,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,
 });
 

package/src/validations/procedure.schema.ts

@@ -52,11 +52,11 @@ export const createProcedureSchema = z.object({
   categoryId: z.string().min(1),
   subcategoryId: z.string().min(1),
   technologyId: z.string().min(1),
-  productId: z.string().min(1),
+  productId: z.string().min(1).optional(),
   price: z.number().min(0),
   currency: z.nativeEnum(Currency),
   pricingMeasure: z.nativeEnum(PricingMeasure),
-  productsMetadata: z.array(procedureProductDataSchema).min(1),
+  productsMetadata: z.array(procedureProductDataSchema).min(1).optional(),
   duration: z.number().min(1).max(480), // Max 8 hours
   practitionerId: z.string().min(1),
   clinicBranchId: z.string().min(1),
@@ -97,8 +97,8 @@ export const procedureSchema = z.object({
   category: z.any(), // We'll validate the full category object separately
   subcategory: z.any(), // We'll validate the full subcategory object separately
   technology: z.any(), // We'll validate the full technology object separately
-  product: z.any(), // We'll validate the full product object separately
-  productsMetadata: z.array(storedProcedureProductSchema).min(1), // Use stored format schema
+  product: z.any().optional(), // We'll validate the full product object separately (optional for consultations)
+  productsMetadata: z.array(storedProcedureProductSchema).optional(), // Use stored format schema (optional for consultations)
   price: z.number().min(0),
   currency: z.nativeEnum(Currency),
   pricingMeasure: z.nativeEnum(PricingMeasure),