@doctocar/tooling 0.3.1-6 → 0.3.1-8

package/dist/firebase/firestore/utils/services/__tests__/getBookableServiceProviderServicesForVehicleType.test.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("../../../../..");
+const enums_1 = require("../../../enums");
+const configs_1 = require("../../configs");
+const stubs_1 = require("../../stubs");
+const getBookableServiceProviderServicesForVehicleType_1 = require("../getBookableServiceProviderServicesForVehicleType");
+jest.mock("../../configs", () => ({
+    getAvailableServicesPublicConfigForVehicleType: jest.fn(),
+}));
+describe("getBookableServiceProviderServicesForVehicleType", () => {
+    let getAvailableServicesPublicConfigForVehicleTypeMock;
+    let getAvailableServicesPublicConfigForVehicleTypeReturn;
+    let serviceProviderUserPublicDocument;
+    beforeEach(() => {
+        getAvailableServicesPublicConfigForVehicleTypeMock =
+            configs_1.getAvailableServicesPublicConfigForVehicleType;
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_1.VehicleTypes.SEDAN,
+                                isActive: true,
+                                pricePreTaxInCents: 2_000,
+                                durationInMinutes: 30,
+                                currency: __1.SupportedIsoCurrency.EUR,
+                            }),
+                        },
+                    }),
+                },
+            });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("delegates service config filtering by vehicle type", () => {
+        (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(getAvailableServicesPublicConfigForVehicleTypeMock).toHaveBeenCalledWith({
+            countryServicesPublicConfig: {},
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+    });
+    it("returns empty arrays when config helper returns no services", () => {
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result).toEqual({
+            mainAvailableProfessionalServices: [],
+            subAvailableProfessionalServices: [],
+        });
+    });
+    it("keeps matching active main and sub services", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+            parentsServices: [],
+        });
+        const carpetShampoo = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.CARPET_SHAMPOO,
+            parentsServices: [enums_1.ServicesTypes.INTERIOR_CLEANING],
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [exteriorCleaning],
+            availableSubServicesPublicConfigList: [carpetShampoo],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.CARPET_SHAMPOO]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([
+            serviceProviderUserPublicDocument.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING],
+        ]);
+        expect(result.availableSubProfessionalServices).toEqual([
+            serviceProviderUserPublicDocument.professionalServices[enums_1.ServicesTypes.CARPET_SHAMPOO],
+        ]);
+    });
+    it("filters out services not offered by the service provider", () => {
+        const unavailableForServiceProvider = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [unavailableForServiceProvider],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([]);
+    });
+    it("filters out services disabled at service provider level", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [exteriorCleaning],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: false,
+                    }),
+                },
+            });
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([]);
+    });
+    it("filters out services with missing pricing for the requested vehicle type", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [exteriorCleaning],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SUV]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_1.VehicleTypes.SUV,
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([]);
+    });
+    it("filters out services with inactive pricing for the requested vehicle type", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [exteriorCleaning],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_1.VehicleTypes.SEDAN,
+                                isActive: false,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([]);
+    });
+    it("preserves service order from vehicle-filtered configuration", () => {
+        const firstService = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        const secondService = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.INTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [firstService, secondService],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([
+            serviceProviderUserPublicDocument.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            serviceProviderUserPublicDocument.professionalServices[enums_1.ServicesTypes.INTERIOR_CLEANING],
+        ]);
+    });
+    it("does not include extra professional services not present in filtered config", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            availableMainServicesPublicConfigList: [exteriorCleaning],
+            availableSubServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.CARPET_SHAMPOO]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getBookableServiceProviderServicesForVehicleType_1.getBookableServiceProviderServicesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainProfessionalServices).toEqual([
+            serviceProviderUserPublicDocument.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING],
+        ]);
+    });
+});

package/dist/firebase/firestore/utils/services/__tests__/{getActiveProfessionalServicePricingAndDurationForVehicleOrThrow.util.test.js → getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow.test.js}

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const enums_1 = require("../../../../../enums");
 const enums_2 = require("../../../enums");
 const stubs_1 = require("../../stubs");
-const getActiveProfessionalServicePricingAndDurationForVehicleOrThrow_1 = require("../getActiveProfessionalServicePricingAndDurationForVehicleOrThrow");
+const getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow_1 = require("../getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow");
 const errorCases = [
     {
-        name: "Should throw an error if the service is not offered by the professional",
+        name: "Should throw an error if the service is not offered by the service provider",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
                     isActive: true,
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: enums_2.VehicleTypes.SEDAN,
@@ -24,17 +24,17 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT,
+        serviceType: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT}” is not offered by this professional.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}” is not offered by this service provider.`),
     },
     {
         name: "Should throw an error if the service is not active",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
                     isActive: false,
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: enums_2.VehicleTypes.SEDAN,
@@ -47,17 +47,17 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not offered by this professional.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not offered by this service provider.`),
     },
     {
         name: "Should throw an error if the vehicle type is not active for the service",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
                     isActive: true,
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.VAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: enums_2.VehicleTypes.VAN,
@@ -70,31 +70,31 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.VAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.VAN}”.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.VAN}”.`),
     },
     {
         name: "Should throw an error if the service does not have pricing and duration for the vehicle type",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     isActive: true,
                     pricingAndDurationByVehicleType: {},
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
     },
     {
         name: "Should throw an error if the service pricing and duration for the vehicle type is missing required pricePreTaxInCents fields",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: enums_2.VehicleTypes.SEDAN,
@@ -107,16 +107,16 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
     },
     {
         name: "Should throw an error if the service pricing and duration for the vehicle type is missing required durationInMinutes fields",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: enums_2.VehicleTypes.SEDAN,
@@ -129,16 +129,16 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
     },
     {
         name: "Should throw an error if the service pricing and duration for the vehicle type is missing required currency fields",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: enums_2.VehicleTypes.SEDAN,
@@ -151,16 +151,16 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
     },
     {
         name: "Should throw an error if the service pricing and duration for the vehicle type is missing required type fields",
         professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
             professionalServices: {
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
-                    type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                     pricingAndDurationByVehicleType: {
                         [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                             type: undefined,
@@ -173,19 +173,19 @@ const errorCases = [
                 }),
             },
         }),
-        professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+        serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
         vehicleType: enums_2.VehicleTypes.SEDAN,
-        error: new Error(`Service “${enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
     },
 ];
-describe("getActiveProfessionalServicePricingAndDurationForVehicleOrThrow", () => {
+describe("getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow", () => {
     let professionalUserPublicDocument;
     beforeEach(() => {
         professionalUserPublicDocument =
             (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
                 professionalServices: {
-                    [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
-                        type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+                    [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                         pricingAndDurationByVehicleType: {
                             [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
                                 type: enums_2.VehicleTypes.SEDAN,
@@ -200,9 +200,9 @@ describe("getActiveProfessionalServicePricingAndDurationForVehicleOrThrow", () =
             });
     });
     it("should return the correct pricing and duration for a valid service and vehicle type (Happy path)", () => {
-        const result = (0, getActiveProfessionalServicePricingAndDurationForVehicleOrThrow_1.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow)({
+        const result = (0, getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow_1.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow)({
             professionalUserPublicDocument,
-            professionalServiceType: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
+            serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
             vehicleType: enums_2.VehicleTypes.SEDAN,
         });
         expect(result).toEqual({
@@ -214,10 +214,10 @@ describe("getActiveProfessionalServicePricingAndDurationForVehicleOrThrow", () =
         });
     });
     describe("error cases", () => {
-        test.each(errorCases)("should throw error if $name", async ({ professionalUserPublicDocument, professionalServiceType, vehicleType, error, }) => {
-            expect(() => (0, getActiveProfessionalServicePricingAndDurationForVehicleOrThrow_1.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow)({
+        test.each(errorCases)("should throw error if $name", async ({ professionalUserPublicDocument, serviceType, vehicleType, error, }) => {
+            expect(() => (0, getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow_1.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow)({
                 professionalUserPublicDocument,
-                professionalServiceType,
+                serviceType,
                 vehicleType,
             })).toThrow(error);
         });

package/dist/firebase/firestore/utils/services/createServiceVehicleComboKey.d.ts

@@ -0,0 +1,2 @@
+import type { ServicesTypes, VehicleTypes } from "../../enums";
+export declare function createServiceVehicleComboKey(serviceType: ServicesTypes, vehicleType: VehicleTypes): string;

package/dist/firebase/firestore/utils/services/createServiceVehicleComboKey.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServiceVehicleComboKey = createServiceVehicleComboKey;
+function createServiceVehicleComboKey(serviceType, vehicleType) {
+    return `${serviceType}_${vehicleType}`;
+}

package/dist/firebase/firestore/utils/services/getBookableServiceProviderServicesForVehicleType.d.ts

@@ -0,0 +1,5 @@
+import type { GetBookableServiceProviderServicesForVehicleTypeParams } from "./types";
+export declare function getBookableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }: GetBookableServiceProviderServicesForVehicleTypeParams): {
+    availableMainProfessionalServices: (import("../..").ProfessionalService<import("../..").ServicesTypes.INTERIOR_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.EXTERIOR_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT> | import("../..").ProfessionalService<import("../..").ServicesTypes.FABRIC_SEAT_SHAMPOO> | import("../..").ProfessionalService<import("../..").ServicesTypes.CARPET_SHAMPOO> | import("../..").ProfessionalService<import("../..").ServicesTypes.CEILING_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.ANIMAL_HAIR_TREATMENT>)[];
+    availableSubProfessionalServices: (import("../..").ProfessionalService<import("../..").ServicesTypes.INTERIOR_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.EXTERIOR_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT> | import("../..").ProfessionalService<import("../..").ServicesTypes.FABRIC_SEAT_SHAMPOO> | import("../..").ProfessionalService<import("../..").ServicesTypes.CARPET_SHAMPOO> | import("../..").ProfessionalService<import("../..").ServicesTypes.CEILING_CLEANING> | import("../..").ProfessionalService<import("../..").ServicesTypes.ANIMAL_HAIR_TREATMENT>)[];
+};

package/dist/firebase/firestore/utils/services/getBookableServiceProviderServicesForVehicleType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBookableServiceProviderServicesForVehicleType = getBookableServiceProviderServicesForVehicleType;
+const configs_1 = require("../configs");
+function getBookableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }) {
+    const { availableMainServicesPublicConfigList, availableSubServicesPublicConfigList, } = (0, configs_1.getAvailableServicesPublicConfigForVehicleType)({
+        countryServicesPublicConfig,
+        vehicleType,
+    });
+    const configMainAvailableServicesTypes = availableMainServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    const configSubAvailableServicesTypes = availableSubServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    return {
+        availableMainProfessionalServices: configMainAvailableServicesTypes.flatMap((serviceType) => {
+            const professionalService = professionalUserPublicDocument.professionalServices[serviceType];
+            if (!professionalService || !professionalService.isActive)
+                return [];
+            const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle?.isActive)
+                return [];
+            return [professionalService];
+        }),
+        availableSubProfessionalServices: configSubAvailableServicesTypes.flatMap((serviceType) => {
+            const professionalService = professionalUserPublicDocument.professionalServices[serviceType];
+            if (!professionalService || !professionalService.isActive)
+                return [];
+            const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle?.isActive)
+                return [];
+            return [professionalService];
+        }),
+    };
+}

package/dist/firebase/firestore/utils/services/getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetServiceProviderActiveServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }: GetServiceProviderActiveServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow = getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow;
+function getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }) {
+    const service = professionalUserPublicDocument.professionalServices?.[serviceType];
+    if (!service || !service.isActive) {
+        throw new Error(`Service “${serviceType}” is not offered by this service provider.`);
+    }
+    const pricingAndDurationForVehicle = service.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${serviceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./createProfessionalServiceVehicleComboKey.util";
-export * from "./getActiveProfessionalServicePricingAndDurationForVehicleOrThrow";
+export * from "./createServiceVehicleComboKey";
+export * from "./getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow";
 export * from "./types";
-export * from "./computeTotalProfessionalServiceDurationInMinutesForVehicleType.util";
-export * from "./areAllRequestedProfessionalUserServicesActiveForVehicleType.util";
+export * from "./computeTotalProfessionalServiceDurationInMinutesForVehicleType";
+export * from "./getBookableServiceProviderServicesForVehicleType";

package/dist/firebase/firestore/utils/services/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./createProfessionalServiceVehicleComboKey.util"), exports);
-__exportStar(require("./getActiveProfessionalServicePricingAndDurationForVehicleOrThrow"), exports);
+__exportStar(require("./createServiceVehicleComboKey"), exports);
+__exportStar(require("./getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./computeTotalProfessionalServiceDurationInMinutesForVehicleType.util"), exports);
-__exportStar(require("./areAllRequestedProfessionalUserServicesActiveForVehicleType.util"), exports);
+__exportStar(require("./computeTotalProfessionalServiceDurationInMinutesForVehicleType"), exports);
+__exportStar(require("./getBookableServiceProviderServicesForVehicleType"), exports);

package/dist/firebase/firestore/utils/services/types/ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs.type.d.ts

@@ -1,7 +1,7 @@
-import type { ProfessionalServicesTypes, VehicleTypes } from "../../../enums";
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
 import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
 export type ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs = {
     professionalServices: FirestoreProfessionalUserPublicDocument["professionalServices"];
-    servicesTypes: ProfessionalServicesTypes[];
+    servicesTypes: ServicesTypes[];
     vehicleType: VehicleTypes;
 };

package/dist/firebase/firestore/utils/services/types/GetBookableServiceProviderServicesForVehicleTypeParams.type.d.ts

@@ -0,0 +1,7 @@
+import type { VehicleTypes } from "../../../enums";
+import type { CountryServicesPublicConfig, FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetBookableServiceProviderServicesForVehicleTypeParams = {
+    countryServicesPublicConfig: CountryServicesPublicConfig;
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    vehicleType: VehicleTypes;
+};