@doctocar/tooling 0.3.1-20 → 0.3.1-22

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

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./isValidServicePricingAndDurationForVehicle"), exports);
-__exportStar(require("./isValidProfessionalService"), exports);
+__exportStar(require("./isValidProviderService"), exports);

package/dist/firebase/firestore/utils/dataValidators/services/isValidProfessionalService.d.ts

@@ -1,2 +1,2 @@
 import type { IsValidProfessionalServiceParams } from "./types";
-export declare function isValidProfessionalService({ professionalService, countryServicePublicConfig, }: IsValidProfessionalServiceParams): Promise<void>;
+export declare function isValidProfessionalService({ providerService, countryServicePublicConfig, }: IsValidProfessionalServiceParams): Promise<void>;

package/dist/firebase/firestore/utils/dataValidators/services/isValidProfessionalService.js

@@ -4,21 +4,21 @@ exports.isValidProfessionalService = isValidProfessionalService;
 const errors_1 = require("../../../../../errors");
 const enums_1 = require("../../../enums");
 const isValidServicePricingAndDurationForVehicle_1 = require("./isValidServicePricingAndDurationForVehicle");
-async function isValidProfessionalService({ professionalService, countryServicePublicConfig, }) {
-    if (professionalService.isActive === undefined ||
-        typeof professionalService.isActive !== "boolean") {
+async function isValidProfessionalService({ providerService, countryServicePublicConfig, }) {
+    if (providerService.isActive === undefined ||
+        typeof providerService.isActive !== "boolean") {
         throw new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE);
     }
-    if (professionalService.type === undefined ||
-        !Object.values(enums_1.ServicesTypes).includes(professionalService.type)) {
+    if (providerService.type === undefined ||
+        !Object.values(enums_1.ServicesTypes).includes(providerService.type)) {
         throw new errors_1.DoctoCarError("Professional service type is required and must be a valid professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
     }
-    const servicePublicConfig = countryServicePublicConfig[professionalService.type];
+    const servicePublicConfig = countryServicePublicConfig[providerService.type];
     if (servicePublicConfig === undefined) {
         throw new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
     }
-    if (professionalService.pricingAndDurationByVehicleType !== undefined) {
-        for (const pricingAndDuration of Object.values(professionalService.pricingAndDurationByVehicleType)) {
+    if (providerService.pricingAndDurationByVehicleType !== undefined) {
+        for (const pricingAndDuration of Object.values(providerService.pricingAndDurationByVehicleType)) {
             if (!(0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)({
                 servicePublicConfig: servicePublicConfig,
                 servicePricingAndDurationForVehicle: pricingAndDuration,
@@ -29,13 +29,13 @@ async function isValidProfessionalService({ professionalService, countryServiceP
     }
     const parentsServices = servicePublicConfig.parentsServices;
     if (parentsServices !== undefined && parentsServices.length > 0) {
-        if (professionalService.parentsServices === undefined ||
-            professionalService.parentsServices.length !== parentsServices.length) {
-            throw new errors_1.DoctoCarError("Professional service parents services are required and must match the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
+        if (providerService.parentsServices === undefined ||
+            providerService.parentsServices.length !== parentsServices.length) {
+            throw new errors_1.DoctoCarError("Service provider service parents services are required and must match the service provider service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
         }
         for (const parentService of parentsServices) {
-            if (!professionalService.parentsServices?.includes(parentService)) {
-                throw new errors_1.DoctoCarError("Professional service parents services are required and must match the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
+            if (!providerService.parentsServices?.includes(parentService)) {
+                throw new errors_1.DoctoCarError("Service provider service parents services are required and must match the service provider service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
             }
         }
     }

package/dist/firebase/firestore/utils/dataValidators/services/isValidProviderService.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidProviderServiceParams } from "./types";
+export declare function isValidProviderService({ providerService, countryServicePublicConfig, }: IsValidProviderServiceParams): Promise<void>;

package/dist/firebase/firestore/utils/dataValidators/services/isValidProviderService.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidProviderService = isValidProviderService;
+const errors_1 = require("../../../../../errors");
+const enums_1 = require("../../../enums");
+const isValidServicePricingAndDurationForVehicle_1 = require("./isValidServicePricingAndDurationForVehicle");
+async function isValidProviderService({ providerService, countryServicePublicConfig, }) {
+    if (providerService.isActive === undefined ||
+        typeof providerService.isActive !== "boolean") {
+        throw new errors_1.DoctoCarError("Provider service isActive must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE);
+    }
+    if (providerService.type === undefined ||
+        !Object.values(enums_1.ServicesTypes).includes(providerService.type)) {
+        throw new errors_1.DoctoCarError("Provider service type is required and must be a valid ServicesTypes value", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
+    }
+    const servicePublicConfig = countryServicePublicConfig[providerService.type];
+    if (servicePublicConfig === undefined) {
+        throw new errors_1.DoctoCarError("Country services public config has no entry for this provider service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
+    }
+    if (providerService.pricingAndDurationByVehicleType !== undefined) {
+        for (const pricingAndDuration of Object.values(providerService.pricingAndDurationByVehicleType)) {
+            if (!(0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)({
+                servicePublicConfig: servicePublicConfig,
+                servicePricingAndDurationForVehicle: pricingAndDuration,
+            })) {
+                throw new errors_1.DoctoCarError("Pricing and duration for this vehicle type is not valid for this provider service", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_VEHICLE_TYPE_PRICING_AND_DURATION);
+            }
+        }
+    }
+    const parentsServices = servicePublicConfig.parentsServices;
+    if (parentsServices !== undefined && parentsServices.length > 0) {
+        if (providerService.parentsServices === undefined ||
+            providerService.parentsServices.length !== parentsServices.length) {
+            throw new errors_1.DoctoCarError("Provider service parent services must match the service type configuration", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
+        }
+        for (const parentService of parentsServices) {
+            if (!providerService.parentsServices?.includes(parentService)) {
+                throw new errors_1.DoctoCarError("Provider service parent services must match the service type configuration", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
+            }
+        }
+    }
+}

package/dist/firebase/firestore/utils/dataValidators/services/isValidServicePricingAndDurationForVehicle.js

@@ -17,13 +17,13 @@ function isValidServicePricingAndDurationForVehicle({ servicePricingAndDurationF
         servicePricingAndDurationForVehicle.pricePreTaxInCents <=
             servicePublicConfigForVehicle.maximumPriceInCents &&
         servicePricingAndDurationForVehicle.pricePreTaxInCents %
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS ===
+            constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS ===
             0 &&
         Object.values(enums_1.SupportedIsoCurrency).includes(servicePricingAndDurationForVehicle.currency) &&
         typeof servicePricingAndDurationForVehicle.durationInMinutes === "number" &&
         servicePricingAndDurationForVehicle.durationInMinutes ==
             servicePublicConfigForVehicle.durationInMinutes &&
         servicePricingAndDurationForVehicle.durationInMinutes %
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES ===
+            constants_1.PROVIDER_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES ===
             0);
 }

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

@@ -1,6 +1,6 @@
 import type { ServicesTypes } from "../../../../enums";
-import type { CountryServicesPublicConfig, ProfessionalService } from "../../../../types";
+import type { CountryServicesPublicConfig, ProviderService } from "../../../../types";
 export type IsValidProfessionalServiceParams = {
-    professionalService: ProfessionalService<ServicesTypes>;
+    providerService: ProviderService<ServicesTypes>;
     countryServicePublicConfig: CountryServicesPublicConfig;
 };

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

@@ -0,0 +1,6 @@
+import type { ServicesTypes } from "../../../../enums";
+import type { CountryServicesPublicConfig, ProviderService } from "../../../../types";
+export type IsValidProviderServiceParams = {
+    providerService: ProviderService<ServicesTypes>;
+    countryServicePublicConfig: CountryServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/services/types/IsValidProviderServiceParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,2 +1,2 @@
 export * from "./IsValidServicePricingAndDurationForVehicleParams.type";
-export * from "./IsValidProfessionalServiceParams.type";
+export * from "./IsValidProviderServiceParams.type";

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

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./IsValidServicePricingAndDurationForVehicleParams.type"), exports);
-__exportStar(require("./IsValidProfessionalServiceParams.type"), exports);
+__exportStar(require("./IsValidProviderServiceParams.type"), exports);

package/dist/firebase/firestore/utils/order/__tests__/buildOrderServicePreTaxLinesAndServicesDetails.test.js

@@ -15,7 +15,7 @@ jest.mock("../../services", () => {
 describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
     let getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock;
     let getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowReturn;
-    let professionalUserPublicDocument;
+    let serviceProviderUserPublicDocument;
     let serviceTypes;
     let vehicleType;
     let countryServicesPublicConfig;
@@ -30,8 +30,8 @@ describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
             type: enums_2.VehicleTypes.MOTORCYCLE,
         };
         getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowReturn);
-        professionalUserPublicDocument =
-            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)();
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)();
         serviceTypes = [
             enums_2.ServicesTypes.EXTERIOR_CLEANING,
             enums_2.ServicesTypes.INTERIOR_CLEANING,
@@ -70,13 +70,13 @@ describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
         getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowReturn);
         const result = (0, buildOrderServicePreTaxLinesAndServicesDetails_1.buildOrderServicePreTaxLinesAndServicesDetails)({
             serviceTypes,
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             vehicleType,
             countryServicesPublicConfig,
         });
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledWith({
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             serviceType: serviceTypes[0],
             vehicleType,
         });
@@ -104,23 +104,23 @@ describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
     it("should map multiple service types and subservices correctly", () => {
         const result = (0, buildOrderServicePreTaxLinesAndServicesDetails_1.buildOrderServicePreTaxLinesAndServicesDetails)({
             serviceTypes,
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             vehicleType,
             countryServicesPublicConfig,
         });
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(3);
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(1, {
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
             vehicleType,
         });
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(2, {
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             serviceType: enums_2.ServicesTypes.INTERIOR_CLEANING,
             vehicleType,
         });
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(3, {
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             serviceType: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
             vehicleType,
         });
@@ -193,13 +193,13 @@ describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
         getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowReturn);
         const result = (0, buildOrderServicePreTaxLinesAndServicesDetails_1.buildOrderServicePreTaxLinesAndServicesDetails)({
             serviceTypes,
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             vehicleType,
             countryServicesPublicConfig,
         });
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
         expect(getServiceProviderActiveServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledWith({
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             serviceType: serviceTypes[0],
             vehicleType,
         });
@@ -231,7 +231,7 @@ describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
         });
         expect(() => (0, buildOrderServicePreTaxLinesAndServicesDetails_1.buildOrderServicePreTaxLinesAndServicesDetails)({
             serviceTypes,
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             vehicleType,
             countryServicesPublicConfig,
         })).toThrow("Service pricing not found");
@@ -250,7 +250,7 @@ describe("buildOrderServicePreTaxLinesAndServicesDetails", () => {
         });
         expect(() => (0, buildOrderServicePreTaxLinesAndServicesDetails_1.buildOrderServicePreTaxLinesAndServicesDetails)({
             serviceTypes,
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             vehicleType,
             countryServicesPublicConfig,
         })).toThrow(`Service type ${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT} is not available in the country configuration.`);

package/dist/firebase/firestore/utils/order/buildOrderServicePreTaxLinesAndServicesDetails.d.ts

@@ -1,2 +1,2 @@
 import type { BuildOrderServicePreTaxLinesAndServicesDetailsReturn, BuildOrderServicePreTaxLinesAndServicesDetailsProps } from "./types";
-export declare function buildOrderServicePreTaxLinesAndServicesDetails({ countryServicesPublicConfig, serviceTypes, professionalUserPublicDocument, vehicleType, }: BuildOrderServicePreTaxLinesAndServicesDetailsProps): BuildOrderServicePreTaxLinesAndServicesDetailsReturn;
+export declare function buildOrderServicePreTaxLinesAndServicesDetails({ countryServicesPublicConfig, serviceTypes, serviceProviderUserPublicDocument, vehicleType, }: BuildOrderServicePreTaxLinesAndServicesDetailsProps): BuildOrderServicePreTaxLinesAndServicesDetailsReturn;

package/dist/firebase/firestore/utils/order/buildOrderServicePreTaxLinesAndServicesDetails.js

@@ -4,7 +4,7 @@ exports.buildOrderServicePreTaxLinesAndServicesDetails = buildOrderServicePreTax
 const pricing_1 = require("../../../../pricing");
 const enums_1 = require("../../enums");
 const services_1 = require("../services");
-function buildOrderServicePreTaxLinesAndServicesDetails({ countryServicesPublicConfig, serviceTypes, professionalUserPublicDocument, vehicleType, }) {
+function buildOrderServicePreTaxLinesAndServicesDetails({ countryServicesPublicConfig, serviceTypes, serviceProviderUserPublicDocument, vehicleType, }) {
     const servicesPreTaxLines = [];
     const orderServicesDetails = [];
     serviceTypes.forEach((serviceType, index) => {
@@ -12,7 +12,7 @@ function buildOrderServicePreTaxLinesAndServicesDetails({ countryServicesPublicC
             throw new Error(`Service type ${serviceType} is not available in the country configuration.`);
         }
         const pricingAndDurationForVehicle = (0, services_1.getServiceProviderActiveServicePricingAndDurationForVehicleOrThrow)({
-            professionalUserPublicDocument,
+            serviceProviderUserPublicDocument,
             serviceType,
             vehicleType,
         });

package/dist/firebase/firestore/utils/order/types/BuildOrderServicePreTaxLinesAndServicesDetailsProps.type.d.ts

@@ -1,8 +1,8 @@
 import type { ServicesTypes, VehicleTypes } from "../../../enums";
-import type { CountryServicesPublicConfig, FirestoreProfessionalUserPublicDocument } from "../../../types";
+import type { CountryServicesPublicConfig, FirestoreServiceProviderUserPublicDocument } from "../../../types";
 export type BuildOrderServicePreTaxLinesAndServicesDetailsProps = {
     countryServicesPublicConfig: CountryServicesPublicConfig;
     serviceTypes: ServicesTypes[];
-    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    serviceProviderUserPublicDocument: FirestoreServiceProviderUserPublicDocument;
     vehicleType: VehicleTypes;
 };

package/dist/firebase/firestore/utils/reviews/__tests__/getAverageRatingFromReviewAggregates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/reviews/__tests__/getAverageRatingFromReviewAggregates.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getAverageRatingFromReviewAggregates_1 = require("../getAverageRatingFromReviewAggregates");
+describe("getAverageRatingFromReviewAggregates", () => {
+    const cases = [
+        {
+            name: "normal positive numbers",
+            input: { reviewCount: 5, ratingSum: 20 },
+            expected: 4,
+        },
+        {
+            name: "zero reviews",
+            input: { reviewCount: 0, ratingSum: 0 },
+            expected: 0,
+        },
+        {
+            name: "positive count, zero sum",
+            input: { reviewCount: 3, ratingSum: 0 },
+            expected: 0,
+        },
+        {
+            name: "negative count",
+            input: { reviewCount: -1, ratingSum: 10 },
+            expected: 0,
+        },
+        {
+            name: "negative sum",
+            input: { reviewCount: 4, ratingSum: -5 },
+            expected: 0,
+        },
+        {
+            name: "both negative",
+            input: { reviewCount: -3, ratingSum: -5 },
+            expected: 0,
+        },
+        {
+            name: "string count coerced",
+            input: { reviewCount: "3", ratingSum: 5 },
+            expected: 1.67,
+        },
+        {
+            name: "string sum coerced",
+            input: { reviewCount: 3, ratingSum: "5" },
+            expected: 1.67,
+        },
+        {
+            name: "string both coerced",
+            input: {
+                reviewCount: "3",
+                ratingSum: "5",
+            },
+            expected: 1.67,
+        },
+        {
+            name: "fractional inputs",
+            input: {
+                reviewCount: 2.5,
+                ratingSum: 5.5,
+            },
+            expected: 2.2,
+        },
+        {
+            name: "sum smaller than count",
+            input: { reviewCount: 10, ratingSum: 5 },
+            expected: 0.5,
+        },
+        {
+            name: "very large numbers",
+            input: { reviewCount: 1e9, ratingSum: 5e9 },
+            expected: 5,
+        },
+        {
+            name: "undefined fields",
+            input: {},
+            expected: 0,
+        },
+        {
+            name: "null inputs",
+            input: {
+                reviewCount: null,
+                ratingSum: null,
+            },
+            expected: 0,
+        },
+        {
+            name: "NaN inputs",
+            input: { reviewCount: NaN, ratingSum: NaN },
+            expected: 0,
+        },
+    ];
+    describe.each(cases)("$name", ({ input, expected }) => {
+        it(`returns ${expected}`, () => {
+            const result = (0, getAverageRatingFromReviewAggregates_1.getAverageRatingFromReviewAggregates)(input);
+            expect(result).toBeCloseTo(expected, 2);
+        });
+    });
+});

package/dist/firebase/firestore/utils/reviews/getAverageRatingFromReviewAggregates.d.ts

@@ -0,0 +1,2 @@
+import type { FirestoreServiceProviderUserPublicDocumentReviewAggregates } from "../../types";
+export declare function getAverageRatingFromReviewAggregates(args: FirestoreServiceProviderUserPublicDocumentReviewAggregates): number;

package/dist/firebase/firestore/utils/reviews/getAverageRatingFromReviewAggregates.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAverageRatingFromReviewAggregates = getAverageRatingFromReviewAggregates;
+function getAverageRatingFromReviewAggregates(args) {
+    const count = Number(args.reviewCount);
+    const sum = Number(args.ratingSum);
+    let averageRating = 0;
+    if (count > 0 && sum > 0) {
+        averageRating = sum / count;
+        averageRating = Math.round(averageRating * 100) / 100;
+    }
+    return averageRating;
+}

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

@@ -1 +1 @@
-export * from "./getAverageRatingFromReviewAggregates.util";
+export * from "./getAverageRatingFromReviewAggregates";

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

@@ -14,4 +14,4 @@ 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("./getAverageRatingFromReviewAggregates.util"), exports);
+__exportStar(require("./getAverageRatingFromReviewAggregates"), exports);

package/dist/firebase/firestore/utils/services/__tests__/computeTotalServiceProviderServiceDurationInMinutesForVehicleType.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../enums");
+const stubs_1 = require("../../stubs");
+const computeTotalServiceProviderServiceDurationInMinutesForVehicleType_1 = require("../computeTotalServiceProviderServiceDurationInMinutesForVehicleType");
+describe("computeTotalServiceProviderServiceDurationInMinutesForVehicleType", () => {
+    let serviceProviderUserPublicDocument;
+    beforeEach(() => { });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("Should return the sum of services durations", () => {
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+                services: {
+                    [enums_1.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.providerServiceStub)({
+                        type: enums_1.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                durationInMinutes: 30,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.CARPET_SHAMPOO]: (0, stubs_1.providerServiceStub)({
+                        type: enums_1.ServicesTypes.CARPET_SHAMPOO,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                durationInMinutes: 30,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                        type: enums_1.ServicesTypes.INTERIOR_CLEANING,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                durationInMinutes: 60,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, computeTotalServiceProviderServiceDurationInMinutesForVehicleType_1.computeTotalServiceProviderServiceDurationInMinutesForVehicleType)({
+            servicesTypes: [
+                enums_1.ServicesTypes.INTERIOR_CLEANING,
+                enums_1.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                enums_1.ServicesTypes.CARPET_SHAMPOO,
+            ],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            services: serviceProviderUserPublicDocument.services,
+        });
+        expect(result).toBe(120);
+    });
+    it("Should throw if service type is not found in services", () => {
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+                services: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                        type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                durationInMinutes: 30,
+                            }),
+                        },
+                    }),
+                },
+            });
+        expect(() => (0, computeTotalServiceProviderServiceDurationInMinutesForVehicleType_1.computeTotalServiceProviderServiceDurationInMinutesForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.INTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            services: serviceProviderUserPublicDocument.services,
+        })).toThrow(`computeTotalServiceProviderServiceDurationInMinutes: Service type ${enums_1.ServicesTypes.INTERIOR_CLEANING} not found for vehicle type ${enums_1.VehicleTypes.CITY_CAR}`);
+    });
+    it("Should throw if a service exists but has no pricingAndDuration for the requested vehicle", async () => {
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreServiceProviderUserPublicDocumentStub)({
+                services: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.providerServiceStub)({
+                        type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                durationInMinutes: 45,
+                            }),
+                        },
+                    }),
+                },
+            });
+        await expect(() => (0, computeTotalServiceProviderServiceDurationInMinutesForVehicleType_1.computeTotalServiceProviderServiceDurationInMinutesForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            services: serviceProviderUserPublicDocument.services,
+        })).toThrow(`computeTotalServiceProviderServiceDurationInMinutes: Service type ${enums_1.ServicesTypes.EXTERIOR_CLEANING} not found for vehicle type ${enums_1.VehicleTypes.CITY_CAR}`);
+    });
+    it("Should throw if services is undefined", () => {
+        expect(() => (0, computeTotalServiceProviderServiceDurationInMinutesForVehicleType_1.computeTotalServiceProviderServiceDurationInMinutesForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            services: undefined,
+        })).toThrow(`computeTotalServiceProviderServiceDurationInMinutes: Service type ${enums_1.ServicesTypes.EXTERIOR_CLEANING} not found for vehicle type ${enums_1.VehicleTypes.CITY_CAR}`);
+    });
+});

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const enums_1 = require("../../../enums");
 const createServiceVehicleComboKey_1 = require("../createServiceVehicleComboKey");
 describe("createServiceVehicleComboKey", () => {
-    it("should return a string with the professionalServiceType and vehicleType separated by an underscore", () => {
-        const professionalServiceType = enums_1.ServicesTypes.INTERIOR_CLEANING;
+    it("should return a string with the serviceType and vehicleType separated by an underscore", () => {
+        const serviceType = enums_1.ServicesTypes.INTERIOR_CLEANING;
         const vehicleType = enums_1.VehicleTypes.CITY_CAR;
-        const result = (0, createServiceVehicleComboKey_1.createServiceVehicleComboKey)(professionalServiceType, vehicleType);
-        expect(result).toBe(`${professionalServiceType}_${vehicleType}`);
+        const result = (0, createServiceVehicleComboKey_1.createServiceVehicleComboKey)(serviceType, vehicleType);
+        expect(result).toBe(`${serviceType}_${vehicleType}`);
     });
 });