@doctocar/tooling 0.3.1-15 → 0.3.1-17

package/dist/firebase/firestore/utils/company/entityDocumentSupportsOrganizationMembers.util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityDocumentSupportsOrganizationMembers = entityDocumentSupportsOrganizationMembers;
+const enums_1 = require("../../../../enums");
+const enums_2 = require("../../enums");
+/**
+ * Organization / multi-member account UI applies to company entities whose
+ * French legal form is not a solo structure (micro-entrepreneur, EI).
+ */
+function entityDocumentSupportsOrganizationMembers(entityDocument) {
+    if (!entityDocument || entityDocument.legalType !== enums_2.EntityLegalType.COMPANY) {
+        return false;
+    }
+    const legalForm = entityDocument.legalDetails?.registration?.data?.legalForm;
+    if (legalForm === enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR ||
+        legalForm === enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1 @@
+export * from "./isIndividualCompany.util";

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./isIndividualCompany.util"), exports);

package/dist/firebase/firestore/utils/company/isIndividualCompany.util.d.ts

@@ -0,0 +1,2 @@
+import type { ProfessionalCompanyDetails } from "../../types";
+export declare function isIndividualCompany(companyDetails: ProfessionalCompanyDetails): boolean;

package/dist/firebase/firestore/utils/company/isIndividualCompany.util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIndividualCompany = isIndividualCompany;
+const enums_1 = require("../../../../enums");
+function isIndividualCompany(companyDetails) {
+    switch (companyDetails.registrationCountry) {
+        case enums_1.SupportedCountryIsoCodes.FRANCE: {
+            const registration = companyDetails.registration[enums_1.SupportedCountryIsoCodes.FRANCE];
+            if (!registration)
+                return false;
+            return (registration.legalForm ===
+                enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE ||
+                registration.legalForm ===
+                    enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR);
+        }
+        default:
+            return false;
+    }
+}

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isCompanyVatValid.util.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isCompanyVatValid.util.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../enums");
+const isCompanyVatValid_util_1 = require("../isCompanyVatValid.util");
+describe("isCompanyVatValid", () => {
+    let companyVatDetails;
+    it("should return true for valid VAT details", () => {
+        companyVatDetails = {
+            isVATExempt: false,
+            vatNumber: "123456789",
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.VERIFIED,
+        };
+        expect((0, isCompanyVatValid_util_1.isCompanyVatValid)(companyVatDetails)).toBe(true);
+    });
+    it("should return false for invalid VAT details", () => {
+        companyVatDetails = {
+            isVATExempt: false,
+            vatNumber: "",
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.PENDING,
+        };
+        expect((0, isCompanyVatValid_util_1.isCompanyVatValid)(companyVatDetails)).toBe(false);
+    });
+    it("should return true for VAT exempt companies", () => {
+        companyVatDetails = {
+            isVATExempt: true,
+            vatNumber: "",
+        };
+        expect((0, isCompanyVatValid_util_1.isCompanyVatValid)(companyVatDetails)).toBe(true);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isLegalAddressValid.util.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/company/__tests__/isLegalAddressValid.util.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../../enums");
+const isLegalAddressValid_util_1 = require("../isLegalAddressValid.util");
+describe("isLegalAddressValid", () => {
+    it("should return true for a valid legal address", () => {
+        const legalAddress = {
+            line1: "123 Main St",
+            postalCode: "12345",
+            city: "Test City",
+            country: enums_1.SupportedCountryIsoCodes.FRANCE,
+        };
+        expect((0, isLegalAddressValid_util_1.isLegalAddressValid)(legalAddress)).toBe(true);
+    });
+    it("should return false for an invalid country code", () => {
+        const legalAddress = {
+            line1: "123 Main St",
+            postalCode: "12345",
+            city: "Test City",
+            country: "XX",
+        };
+        expect((0, isLegalAddressValid_util_1.isLegalAddressValid)(legalAddress)).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/company/isCompanyVatValid.util.d.ts

@@ -0,0 +1,2 @@
+import type { CompanyVATDetails } from "../../../types";
+export declare function isCompanyVatValid(companyVatDetails: CompanyVATDetails): boolean;

package/dist/firebase/firestore/utils/dataValidators/company/isCompanyVatValid.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompanyVatValid = isCompanyVatValid;
+const enums_1 = require("../../../enums");
+function isCompanyVatValid(companyVatDetails) {
+    return (companyVatDetails.isVATExempt ||
+        (Boolean(companyVatDetails.vatNumber) &&
+            companyVatDetails.vatNumberVerificationStatus ===
+                enums_1.VatVerificationStatus.VERIFIED));
+}

package/dist/firebase/firestore/utils/dataValidators/company/isLegalAddressValid.util.d.ts

@@ -0,0 +1,2 @@
+import type { LegalAddress } from "../../../types";
+export declare function isLegalAddressValid(legalAddress: LegalAddress): boolean;

package/dist/firebase/firestore/utils/dataValidators/company/isLegalAddressValid.util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegalAddressValid = isLegalAddressValid;
+const enums_1 = require("../../../../../enums");
+function isLegalAddressValid(legalAddress) {
+    return Object.values(enums_1.SupportedCountryIsoCodes).includes(legalAddress.country);
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalService.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalService.test.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../../../enums");
+const errors_1 = require("../../../../../../errors");
+const enums_2 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const isValidProfessionalService_1 = require("../isValidProfessionalService");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+jest.mock("../isValidVehicleForProfessionalService");
+jest.mock("../isValidServicePricingAndDurationForVehicle");
+describe("isValidProfessionalService", () => {
+    let defaultProps;
+    let isValidServicePricingAndDurationForVehicleMock;
+    let isValidServicePricingAndDurationForVehicleReturnValue;
+    beforeEach(() => {
+        defaultProps = {
+            professionalService: {
+                isActive: true,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                pricingAndDurationByVehicleType: {
+                    [enums_2.VehicleTypes.SEDAN]: {
+                        isActive: true,
+                        type: enums_2.VehicleTypes.SEDAN,
+                        pricePreTaxInCents: 2000,
+                        currency: enums_1.SupportedIsoCurrency.EUR,
+                        durationInMinutes: 30,
+                    },
+                },
+            },
+            countryProfessionalServicePublicConfig: (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({}),
+            }),
+        };
+        isValidServicePricingAndDurationForVehicleMock =
+            isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle;
+        isValidServicePricingAndDurationForVehicleReturnValue = true;
+        isValidServicePricingAndDurationForVehicleMock.mockImplementation(() => {
+            return isValidServicePricingAndDurationForVehicleReturnValue;
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should not throw if is a valid service with empty pricing and empty subservice", async () => {
+        await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
+    });
+    describe("Active", () => {
+        it("should throw if the active field is not a boolean", async () => {
+            defaultProps.professionalService.isActive = "yes";
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the active field is not provided", async () => {
+            defaultProps.professionalService.isActive = undefined;
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Service type", () => {
+        it("should throw if the service type is not a valid ServicesTypes", async () => {
+            defaultProps.professionalService.type = "INVALID_TYPE";
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the type is not provided", async () => {
+            defaultProps.professionalService.type = undefined;
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Professional service public config", () => {
+        it("should throw if the professional service public config is not defined for the professional service type", async () => {
+            defaultProps.countryProfessionalServicePublicConfig = {};
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Price and duration", () => {
+        it("should not throw if isValidServicePricingAndDurationForVehicle return true", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = true;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
+                professionalServicePublicConfig: defaultProps.countryProfessionalServicePublicConfig[defaultProps.professionalService.type],
+                servicePricingAndDuration: defaultProps.professionalService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+            });
+        });
+        it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = false;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+    });
+    describe("parentsServices", () => {
+        it("Should throw if a service does not have the parents services indicated in the config", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryProfessionalServicePublicConfig =
+                (0, stubs_1.countryServicesPublicConfigStub)({
+                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                        parentsServices: [
+                            enums_2.ServicesTypes.INTERIOR_CLEANING,
+                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                        ],
+                    }),
+                });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryProfessionalServicePublicConfig =
+                (0, stubs_1.countryServicesPublicConfigStub)({
+                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                        parentsServices: [
+                            enums_2.ServicesTypes.INTERIOR_CLEANING,
+                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                        ],
+                    }),
+                });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryProfessionalServicePublicConfig =
+                (0, stubs_1.countryServicesPublicConfigStub)({
+                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                        parentsServices: [
+                            enums_2.ServicesTypes.INTERIOR_CLEANING,
+                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                        ],
+                    }),
+                });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryProfessionalServicePublicConfig =
+                (0, stubs_1.countryServicesPublicConfigStub)({
+                    [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                        parentsServices: [
+                            enums_2.ServicesTypes.INTERIOR_CLEANING,
+                            enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                        ],
+                    }),
+                });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServicePricingAndDurationForVehicle.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServicePricingAndDurationForVehicle.test.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../../../enums");
+const constants_1 = require("../../../../constants");
+const enums_2 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const isValidProfessionalServicePricingAndDurationForVehicle_1 = require("../isValidProfessionalServicePricingAndDurationForVehicle");
+describe("isValidProfessionalServicePricingAndDurationForVehicle", () => {
+    let defaultProps;
+    let minimumPriceInCents;
+    let maximumPriceInCents;
+    let durationInMinutes;
+    beforeEach(() => {
+        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        maximumPriceInCents =
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
+        durationInMinutes =
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        defaultProps = {
+            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                byVehicleType: {
+                    [enums_2.VehicleTypes.CITY_CAR]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.SUV]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.MOTORCYCLE]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.SEDAN]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.PICKUP_TRUCK]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.VAN]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                },
+                allowedVehicles: [enums_2.VehicleTypes.CITY_CAR],
+            }),
+            servicePricingAndDuration: {
+                isActive: true,
+                type: enums_2.VehicleTypes.CITY_CAR,
+                pricePreTaxInCents: minimumPriceInCents,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+                durationInMinutes: durationInMinutes,
+            },
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should return true if pricing is valid for service", () => {
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
+    });
+    it("Should return false if active is not a boolean", () => {
+        defaultProps.servicePricingAndDuration.isActive = "Not a boolean";
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is not a number", () => {
+        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+            "Not a number";
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
+        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+            minimumPriceInCents -
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
+        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+            maximumPriceInCents +
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is not a multiple of PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
+        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+            maximumPriceInCents - 1;
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if SupportedIsoCurrency is not a valid currency", () => {
+        defaultProps.servicePricingAndDuration.currency =
+            "Not a valid currency";
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is not a number", () => {
+        defaultProps.servicePricingAndDuration.durationInMinutes =
+            "Not a number";
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is less than the duration for the service", () => {
+        defaultProps.servicePricingAndDuration.durationInMinutes =
+            durationInMinutes -
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is more than the duration for the service", () => {
+        defaultProps.servicePricingAndDuration.durationInMinutes =
+            durationInMinutes +
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if the type is not a valid vehicle type", () => {
+        defaultProps.servicePricingAndDuration.type = "Not a vehicle type";
+        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServiceType.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidProfessionalServiceType.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../enums");
+const isValidProfessionalServiceType_1 = require("../isValidProfessionalServiceType");
+describe("isValidProfessionalServiceType", () => {
+    describe.each(Object.values(enums_1.ServicesTypes))("when the service type is %p", (serviceType) => {
+        it("should return true", () => {
+            expect((0, isValidProfessionalServiceType_1.isValidProfessionalServiceType)(serviceType)).toBe(true);
+        });
+    });
+    it("should return false when the service type is unknown", () => {
+        expect((0, isValidProfessionalServiceType_1.isValidProfessionalServiceType)("UNKNOWN_SERVICE_TYPE")).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidServicePricingAndDurationForVehicle.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidServicePricingAndDurationForVehicle.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../../../enums");
+const constants_1 = require("../../../../constants");
+const enums_2 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+describe("isValidServicePricingAndDurationForVehicle", () => {
+    let defaultProps;
+    let minimumPriceInCents;
+    let maximumPriceInCents;
+    let durationInMinutes;
+    beforeEach(() => {
+        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        maximumPriceInCents =
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
+        durationInMinutes =
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        defaultProps = {
+            servicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                byVehicleType: {
+                    [enums_2.VehicleTypes.CITY_CAR]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.SUV]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.MOTORCYCLE]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.SEDAN]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.PICKUP_TRUCK]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.VAN]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                },
+            }),
+            servicePricingAndDurationForVehicle: {
+                isActive: true,
+                type: enums_2.VehicleTypes.CITY_CAR,
+                pricePreTaxInCents: minimumPriceInCents,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+                durationInMinutes: durationInMinutes,
+            },
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should return true if pricing is valid for service", () => {
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
+    });
+    it("Should return false if active is not a boolean", () => {
+        defaultProps.servicePricingAndDurationForVehicle.isActive =
+            "Not a boolean";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if service public config is not defined for the vehicle type", () => {
+        defaultProps.servicePublicConfig.byVehicleType = {
+            [enums_2.VehicleTypes.CITY_CAR]: undefined,
+        };
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is not a number", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            "Not a number";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            minimumPriceInCents -
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            maximumPriceInCents +
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is not a multiple of PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            maximumPriceInCents - 1;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if SupportedIsoCurrency is not a valid currency", () => {
+        defaultProps.servicePricingAndDurationForVehicle.currency =
+            "Not a valid currency";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is not a number", () => {
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
+            "Not a number";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is less than the duration for the service", () => {
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
+            durationInMinutes -
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is more than the duration for the service", () => {
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
+            durationInMinutes +
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if the type is not a valid vehicle type", () => {
+        defaultProps.servicePricingAndDurationForVehicle.type =
+            "Not a vehicle type";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidVehicleForProfessionalService.test.d.ts

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