@blackcode_sa/metaestetics-api 1.12.47 → 1.12.49

package/dist/index.js

@@ -16326,7 +16326,8 @@ var createProcedureSchema = import_zod26.z.object({
   price: import_zod26.z.number().min(0),
   currency: import_zod26.z.nativeEnum(Currency),
   pricingMeasure: import_zod26.z.nativeEnum(PricingMeasure),
-  productsMetadata: import_zod26.z.array(procedureProductDataSchema).min(1).optional(),
+  productsMetadata: import_zod26.z.array(procedureProductDataSchema).optional(),
+  // No min(1) - allow empty for product-free procedures
   duration: import_zod26.z.number().min(1).max(480),
   // Max 8 hours
   practitionerId: import_zod26.z.string().min(1),
@@ -16340,7 +16341,8 @@ var updateProcedureSchema = import_zod26.z.object({
   price: import_zod26.z.number().min(0).optional(),
   currency: import_zod26.z.nativeEnum(Currency).optional(),
   pricingMeasure: import_zod26.z.nativeEnum(PricingMeasure).optional(),
-  productsMetadata: import_zod26.z.array(procedureProductDataSchema).min(1).optional(),
+  productsMetadata: import_zod26.z.array(procedureProductDataSchema).optional(),
+  // No min(1) - allow empty for product-free procedures
   duration: import_zod26.z.number().min(0).optional(),
   isActive: import_zod26.z.boolean().optional(),
   practitionerId: import_zod26.z.string().optional(),
@@ -16493,20 +16495,29 @@ var ProcedureService = class extends BaseService {
   async createProcedure(data) {
     var _a, _b, _c;
     const validatedData = createProcedureSchema.parse(data);
-    if (!validatedData.productId) {
-      throw new Error("productId is required for regular procedures. Use createConsultationProcedure for product-free procedures.");
-    }
+    const isProductFree = !validatedData.productId;
     const procedureId = this.generateId();
-    const [category, subcategory, technology, product] = 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)
-      // Safe: validated above
-    ]);
-    if (!category || !subcategory || !technology || !product) {
+      this.technologyService.getById(validatedData.technologyId)
+    ];
+    if (!isProductFree) {
+      baseEntitiesPromises.push(
+        this.productService.getById(validatedData.technologyId, validatedData.productId)
+      );
+    }
+    const results = await Promise.all(baseEntitiesPromises);
+    const category = results[0];
+    const subcategory = results[1];
+    const technology = results[2];
+    const product = isProductFree ? void 0 : results[3] || void 0;
+    if (!category || !subcategory || !technology) {
       throw new Error("One or more required base entities not found");
     }
+    if (!isProductFree && !product) {
+      throw new Error("Product not found for regular procedure");
+    }
     const clinicRef = (0, import_firestore55.doc)(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
     const clinicSnapshot = await (0, import_firestore55.getDoc)(clinicRef);
     if (!clinicSnapshot.exists()) {
@@ -16611,23 +16622,35 @@ var ProcedureService = class extends BaseService {
     if (!practitionerIds || practitionerIds.length === 0) {
       throw new Error("Practitioner IDs array cannot be empty.");
     }
-    if (!baseData.productId) {
-      throw new Error("productId is required for regular procedures. Use createConsultationProcedure for product-free procedures.");
-    }
+    const isProductFree = !baseData.productId;
     const validationData = { ...baseData, practitionerId: practitionerIds[0] };
     const validatedData = createProcedureSchema.parse(validationData);
-    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),
-      // Safe: validated above
-      (0, import_firestore55.getDoc)((0, import_firestore55.doc)(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId))
+      this.technologyService.getById(validatedData.technologyId)
+    ];
+    if (!isProductFree) {
+      baseEntitiesPromises.push(
+        this.productService.getById(validatedData.technologyId, validatedData.productId)
+      );
+    }
+    const clinicSnapshotPromise = (0, import_firestore55.getDoc)((0, import_firestore55.doc)(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId));
+    const [baseResults, clinicSnapshot] = await Promise.all([
+      Promise.all(baseEntitiesPromises),
+      clinicSnapshotPromise
     ]);
-    if (!category || !subcategory || !technology || !product) {
+    const category = baseResults[0];
+    const subcategory = baseResults[1];
+    const technology = baseResults[2];
+    const product = isProductFree ? void 0 : baseResults[3] || void 0;
+    if (!category || !subcategory || !technology) {
       throw new Error("One or more required base entities not found");
     }
-    if (!clinicSnapshot.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();

package/dist/index.mjs

@@ -16574,7 +16574,8 @@ var createProcedureSchema = z26.object({
   price: z26.number().min(0),
   currency: z26.nativeEnum(Currency),
   pricingMeasure: z26.nativeEnum(PricingMeasure),
-  productsMetadata: z26.array(procedureProductDataSchema).min(1).optional(),
+  productsMetadata: z26.array(procedureProductDataSchema).optional(),
+  // No min(1) - allow empty for product-free procedures
   duration: z26.number().min(1).max(480),
   // Max 8 hours
   practitionerId: z26.string().min(1),
@@ -16588,7 +16589,8 @@ var updateProcedureSchema = z26.object({
   price: z26.number().min(0).optional(),
   currency: z26.nativeEnum(Currency).optional(),
   pricingMeasure: z26.nativeEnum(PricingMeasure).optional(),
-  productsMetadata: z26.array(procedureProductDataSchema).min(1).optional(),
+  productsMetadata: z26.array(procedureProductDataSchema).optional(),
+  // No min(1) - allow empty for product-free procedures
   duration: z26.number().min(0).optional(),
   isActive: z26.boolean().optional(),
   practitionerId: z26.string().optional(),
@@ -16741,20 +16743,29 @@ var ProcedureService = class extends BaseService {
   async createProcedure(data) {
     var _a, _b, _c;
     const validatedData = createProcedureSchema.parse(data);
-    if (!validatedData.productId) {
-      throw new Error("productId is required for regular procedures. Use createConsultationProcedure for product-free procedures.");
-    }
+    const isProductFree = !validatedData.productId;
     const procedureId = this.generateId();
-    const [category, subcategory, technology, product] = 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)
-      // Safe: validated above
-    ]);
-    if (!category || !subcategory || !technology || !product) {
+      this.technologyService.getById(validatedData.technologyId)
+    ];
+    if (!isProductFree) {
+      baseEntitiesPromises.push(
+        this.productService.getById(validatedData.technologyId, validatedData.productId)
+      );
+    }
+    const results = await Promise.all(baseEntitiesPromises);
+    const category = results[0];
+    const subcategory = results[1];
+    const technology = results[2];
+    const product = isProductFree ? void 0 : results[3] || void 0;
+    if (!category || !subcategory || !technology) {
       throw new Error("One or more required base entities not found");
     }
+    if (!isProductFree && !product) {
+      throw new Error("Product not found for regular procedure");
+    }
     const clinicRef = doc36(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
     const clinicSnapshot = await getDoc37(clinicRef);
     if (!clinicSnapshot.exists()) {
@@ -16859,23 +16870,35 @@ var ProcedureService = class extends BaseService {
     if (!practitionerIds || practitionerIds.length === 0) {
       throw new Error("Practitioner IDs array cannot be empty.");
     }
-    if (!baseData.productId) {
-      throw new Error("productId is required for regular procedures. Use createConsultationProcedure for product-free procedures.");
-    }
+    const isProductFree = !baseData.productId;
     const validationData = { ...baseData, practitionerId: practitionerIds[0] };
     const validatedData = createProcedureSchema.parse(validationData);
-    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),
-      // Safe: validated above
-      getDoc37(doc36(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId))
+      this.technologyService.getById(validatedData.technologyId)
+    ];
+    if (!isProductFree) {
+      baseEntitiesPromises.push(
+        this.productService.getById(validatedData.technologyId, validatedData.productId)
+      );
+    }
+    const clinicSnapshotPromise = getDoc37(doc36(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId));
+    const [baseResults, clinicSnapshot] = await Promise.all([
+      Promise.all(baseEntitiesPromises),
+      clinicSnapshotPromise
     ]);
-    if (!category || !subcategory || !technology || !product) {
+    const category = baseResults[0];
+    const subcategory = baseResults[1];
+    const technology = baseResults[2];
+    const product = isProductFree ? void 0 : baseResults[3] || void 0;
+    if (!category || !subcategory || !technology) {
       throw new Error("One or more required base entities not found");
     }
-    if (!clinicSnapshot.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();

package/package.json

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

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

@@ -194,26 +194,41 @@ 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.');
-    }
+    // 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!), // Safe: validated above
-    ]);
+    ];
+
+    // 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);
@@ -343,28 +358,50 @@ 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.');
-    }
+    // 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!), // Safe: validated above
-      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;

package/src/validations/procedure.schema.ts

@@ -56,7 +56,7 @@ export const createProcedureSchema = z.object({
   price: z.number().min(0),
   currency: z.nativeEnum(Currency),
   pricingMeasure: z.nativeEnum(PricingMeasure),
-  productsMetadata: z.array(procedureProductDataSchema).min(1).optional(),
+  productsMetadata: z.array(procedureProductDataSchema).optional(), // No min(1) - allow empty for product-free procedures
   duration: z.number().min(1).max(480), // Max 8 hours
   practitionerId: z.string().min(1),
   clinicBranchId: z.string().min(1),
@@ -73,7 +73,7 @@ export const updateProcedureSchema = z.object({
   price: z.number().min(0).optional(),
   currency: z.nativeEnum(Currency).optional(),
   pricingMeasure: z.nativeEnum(PricingMeasure).optional(),
-  productsMetadata: z.array(procedureProductDataSchema).min(1).optional(),
+  productsMetadata: z.array(procedureProductDataSchema).optional(), // No min(1) - allow empty for product-free procedures
   duration: z.number().min(0).optional(),
   isActive: z.boolean().optional(),
   practitionerId: z.string().optional(),