@doctocar/tooling 0.3.1-21 → 0.3.1-22

package/dist/firebase/firestore/enums/ordersIssues/index.js

@@ -17,4 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./OrderIssueStatusTypes.enum"), exports);
 __exportStar(require("./OrderIssueSeverityLevel.enum"), exports);
 __exportStar(require("./CustomerOrderIssueReason.enum"), exports);
-__exportStar(require("./ProfessionalOrderIssueReason.enum"), exports);
+__exportStar(require("./ServiceProviderOrderIssueReason.enum"), exports);

package/dist/firebase/firestore/enums/users/professionals/ServiceProviderBadgesTypes.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum ServiceProviderBadgesTypes {
+    PROFESSIONAL_LIABILITY_INSURANCE = "professional_liability_insurance"
+}

package/dist/firebase/firestore/enums/users/professionals/ServiceProviderBadgesTypes.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceProviderBadgesTypes = void 0;
+var ServiceProviderBadgesTypes;
+(function (ServiceProviderBadgesTypes) {
+    ServiceProviderBadgesTypes["PROFESSIONAL_LIABILITY_INSURANCE"] = "professional_liability_insurance";
+})(ServiceProviderBadgesTypes || (exports.ServiceProviderBadgesTypes = ServiceProviderBadgesTypes = {}));

package/dist/firebase/firestore/enums/users/professionals/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./ProfessionalInsurancesTypes.enum";
 export * from "./ProfessionalDiplomasTypes.enum";
-export * from "./ProfessionalBadgesTypes.enum";
+export * from "./ServiceProviderBadgesTypes.enum";

package/dist/firebase/firestore/enums/users/professionals/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ProfessionalInsurancesTypes.enum"), exports);
 __exportStar(require("./ProfessionalDiplomasTypes.enum"), exports);
-__exportStar(require("./ProfessionalBadgesTypes.enum"), exports);
+__exportStar(require("./ServiceProviderBadgesTypes.enum"), exports);

package/dist/firebase/firestore/maps/FirestoreCollectionDocumentTypeMap.d.ts

@@ -1,9 +1,9 @@
 import { FirestoreCollections } from "../enums";
-import type { FirestoreBookedSlotDocument, FirestoreDailyMetricsDocument, FirestoreDebugPublicConfigDocument, FirestoreDeviceTokenDocument, FirestoreEmailsBlacklistDocument, FirestoreEmailsSoftBounceDocument, FirestoreEntityDocument, FirestoreEntityMemberDocument, FirestoreEntityMemberInviteDocument, FirestoreEntityUniqueKeyDocument, FirestoreFunctionsDeploymentRunsDocument, FirestoreGlobalMetricsDocument, FirestoreInvoiceCounterDocument, FirestoreMarketplaceFinancialReportsDocument, FirestoreMessageDocument, FirestoreNotificationEventDeliveryStateDocument, FirestoreNotificationEventsPublicConfigDocument, FirestoreOnTaskExecutionStateDocument, FirestoreOrderDocument, FirestoreOrderIssueDocument, FirestoreOrderReviewDocument, FirestoreOrdersPublicConfigDocument, FirestorePaymentIntentDocument, FirestorePlatformPublicConfigDocument, FirestorePricingPublicConfigDocument, FirestoreProfessionalUserPublicDocument, FirestorePromoCodeDocument, FirestoreRateLimitDocument, FirestoreServicesPublicConfigDocument, FirestoreSlotDocument, FirestoreUserDocument, FirestoreUserUploadRateLimitDocument, FirestoreVehicleDocument, FirestoreWalletsDocument, FirestoreWalletsLedgerEntryDocument, FirestoreWalletsWithdrawalIntentsDocument } from "../types";
+import type { FirestoreBookedSlotDocument, FirestoreDailyMetricsDocument, FirestoreDebugPublicConfigDocument, FirestoreDeviceTokenDocument, FirestoreEmailsBlacklistDocument, FirestoreEmailsSoftBounceDocument, FirestoreEntityDocument, FirestoreEntityMemberDocument, FirestoreEntityMemberInviteDocument, FirestoreEntityUniqueKeyDocument, FirestoreFunctionsDeploymentRunsDocument, FirestoreGlobalMetricsDocument, FirestoreInvoiceCounterDocument, FirestoreMarketplaceFinancialReportsDocument, FirestoreMessageDocument, FirestoreNotificationEventDeliveryStateDocument, FirestoreNotificationEventsPublicConfigDocument, FirestoreOnTaskExecutionStateDocument, FirestoreOrderDocument, FirestoreOrderIssueDocument, FirestoreOrderReviewDocument, FirestoreOrdersPublicConfigDocument, FirestorePaymentIntentDocument, FirestorePlatformPublicConfigDocument, FirestorePricingPublicConfigDocument, FirestoreServiceProviderUserPublicDocument, FirestorePromoCodeDocument, FirestoreRateLimitDocument, FirestoreServicesPublicConfigDocument, FirestoreSlotDocument, FirestoreUserDocument, FirestoreUserUploadRateLimitDocument, FirestoreVehicleDocument, FirestoreWalletsDocument, FirestoreWalletsLedgerEntryDocument, FirestoreWalletsWithdrawalIntentsDocument } from "../types";
 type FirestoreCollectionDocumentTypeMapBase = {
     [FirestoreCollections.USERS]: FirestoreUserDocument;
     [FirestoreCollections.DEVICE_TOKENS]: FirestoreDeviceTokenDocument;
-    [FirestoreCollections.PROFESSIONAL_USERS_PUBLIC]: FirestoreProfessionalUserPublicDocument;
+    [FirestoreCollections.SERVICE_PROVIDER_USERS_PUBLIC]: FirestoreServiceProviderUserPublicDocument;
     [FirestoreCollections.WALLETS]: FirestoreWalletsDocument;
     [FirestoreCollections.WALLETS_LEDGER_ENTRIES]: FirestoreWalletsLedgerEntryDocument;
     [FirestoreCollections.WALLETS_WITHDRAWAL_INTENTS]: FirestoreWalletsWithdrawalIntentsDocument;

package/dist/firebase/firestore/types/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./userDocument";
 export * from "./messages";
 export * from "./services";
-export * from "./userPublicDocument";
+export * from "./serviceProviderUserPublicDocument";
 export * from "./rateLimitDocument";
 export * from "./FirestoreFile.type";
 export * from "./location";

package/dist/firebase/firestore/types/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./userDocument"), exports);
 __exportStar(require("./messages"), exports);
 __exportStar(require("./services"), exports);
-__exportStar(require("./userPublicDocument"), exports);
+__exportStar(require("./serviceProviderUserPublicDocument"), exports);
 __exportStar(require("./rateLimitDocument"), exports);
 __exportStar(require("./FirestoreFile.type"), exports);
 __exportStar(require("./location"), exports);

package/dist/firebase/firestore/types/order/FirestoreOrderCancellationReason.type.d.ts

@@ -1,2 +1,2 @@
-import type { OrderCustomerCancellationReason, OrderPaymentCancellationReason, OrderProfessionalCancellationReason, OrderSystemCancellationReason } from "../../enums";
-export type FirestoreOrderCancellationReason = OrderSystemCancellationReason | OrderCustomerCancellationReason | OrderProfessionalCancellationReason | OrderPaymentCancellationReason;
+import type { OrderCustomerCancellationReason, OrderPaymentCancellationReason, OrderServiceProviderCancellationReason, OrderSystemCancellationReason } from "../../enums";
+export type FirestoreOrderCancellationReason = OrderSystemCancellationReason | OrderCustomerCancellationReason | OrderServiceProviderCancellationReason | OrderPaymentCancellationReason;

package/dist/firebase/firestore/types/ordersIssues/OrderIssueReason.type.d.ts

@@ -1,2 +1,2 @@
-import type { CustomerOrderIssueReason, ProfessionalOrderIssueReason } from "../../enums";
-export type OrderIssueReason = CustomerOrderIssueReason | ProfessionalOrderIssueReason;
+import type { CustomerOrderIssueReason, ServiceProviderOrderIssueReason } from "../../enums";
+export type OrderIssueReason = CustomerOrderIssueReason | ServiceProviderOrderIssueReason;

package/dist/firebase/firestore/types/ordersReviews/FirestoreOrderReviewDocument.type.d.ts

@@ -5,7 +5,7 @@ export type FirestoreOrderReviewDocument = {
     updatedAt: FirestoreTimestamp;
     orderId: string;
     customerId: string;
-    professionalId: string;
+    serviceProviderId: string;
     status: OrderReviewStatusType;
     rating?: number;
     comment?: string;

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocument.type.d.ts

@@ -0,0 +1,49 @@
+import type { SupportedCountryIsoCodes } from "../../../../enums";
+import type { ServiceProviderBadgesTypes, ServicesTypes } from "../../enums";
+import type { FirestoreTimestamp } from "../FirestoreTimestamp.type";
+import type { FirestoreImageVariantSet } from "../image";
+import type { ProviderService } from "../services/ProviderService.type";
+import type { FirestoreServiceProviderUserPublicDocumentReviewAggregates } from "./FirestoreServiceProviderUserPublicDocumentReviewAggregates.type";
+import type { FirestoreServiceProviderUserPublicDocumentServicesLocation } from "./FirestoreServiceProviderUserPublicDocumentServicesLocation.type";
+export type FirestoreServiceProviderUserPublicDocument = {
+    createdAt: FirestoreTimestamp;
+    updatedAt: FirestoreTimestamp;
+    version: 1;
+    userId: string;
+    entityId: string;
+    entityDisplayName: string;
+    countryIsoCode: SupportedCountryIsoCodes;
+    isVatExempt: boolean;
+    profile?: {
+        photo?: {
+            storagePaths: FirestoreImageVariantSet;
+            updatedAt: FirestoreTimestamp;
+        };
+    };
+    coverPicture?: {
+        storagePaths: FirestoreImageVariantSet;
+        updatedAt: FirestoreTimestamp;
+    };
+    publicDescription?: string;
+    activeServicesVehiclesCombos: string[];
+    services: Partial<{
+        [T in ServicesTypes]: ProviderService<T>;
+    }>;
+    reviewAggregates: FirestoreServiceProviderUserPublicDocumentReviewAggregates;
+    servicesLocation: FirestoreServiceProviderUserPublicDocumentServicesLocation;
+    availability: {
+        horizonStart: FirestoreTimestamp;
+        horizonDays: number;
+        granularityMinutes: number;
+        encodedOpenTimeline: string;
+        encodedBlockedTimeline: string;
+        updatedAt: FirestoreTimestamp;
+    };
+    isBookable: boolean;
+    badges?: Partial<Record<ServiceProviderBadgesTypes, {
+        grantedAt: FirestoreTimestamp;
+        expiredAt?: FirestoreTimestamp;
+        metadata?: Record<string, unknown>;
+    }>>;
+    isTest: boolean;
+};

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocument.type.js

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

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentReviewAggregates.type.d.ts

@@ -0,0 +1,4 @@
+export type FirestoreServiceProviderUserPublicDocumentReviewAggregates = {
+    reviewCount: number;
+    ratingSum: number;
+};

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentReviewAggregates.type.js

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

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentServicesLocation.type.d.ts

@@ -0,0 +1,4 @@
+import type { DoctoCarLocation } from "../location";
+export type FirestoreServiceProviderUserPublicDocumentServicesLocation = {
+    serviceLocationRadiusInKm: number;
+} & DoctoCarLocation;

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentServicesLocation.type.js

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

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FirestoreServiceProviderUserPublicDocument.type";
+export * from "./FirestoreServiceProviderUserPublicDocumentServicesLocation.type";
+export * from "./FirestoreServiceProviderUserPublicDocumentReviewAggregates.type";

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/index.js

@@ -0,0 +1,19 @@
+"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("./FirestoreServiceProviderUserPublicDocument.type"), exports);
+__exportStar(require("./FirestoreServiceProviderUserPublicDocumentServicesLocation.type"), exports);
+__exportStar(require("./FirestoreServiceProviderUserPublicDocumentReviewAggregates.type"), exports);

package/dist/firebase/firestore/types/services/ProviderService.type.d.ts

@@ -0,0 +1,8 @@
+import { ServicesTypes, type VehicleTypes } from "../../enums";
+import type { ServicePricingAndDurationForVehicle } from "./ServicePricingAndDurationForVehicle.type";
+export type ProviderService<T extends ServicesTypes> = {
+    type: T;
+    isActive: boolean;
+    parentsServices?: ServicesTypes[];
+    pricingAndDurationByVehicleType: Partial<Record<VehicleTypes, ServicePricingAndDurationForVehicle>>;
+};

package/dist/firebase/firestore/types/services/ProviderService.type.js

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

package/dist/firebase/firestore/types/services/ServiceProviderService.type.d.ts

@@ -0,0 +1,8 @@
+import { ServicesTypes, type VehicleTypes } from "../../enums";
+import type { ServicePricingAndDurationForVehicle } from "./ServicePricingAndDurationForVehicle.type";
+export type ServiceProviderService<T extends ServicesTypes> = {
+    type: T;
+    isActive: boolean;
+    parentsServices?: ServicesTypes[];
+    pricingAndDurationByVehicleType: Partial<Record<VehicleTypes, ServicePricingAndDurationForVehicle>>;
+};

package/dist/firebase/firestore/types/services/ServiceProviderService.type.js

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

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

@@ -1,2 +1,2 @@
-export * from "./ProfessionalService.type";
+export * from "./ProviderService.type";
 export * from "./ServicePricingAndDurationForVehicle.type";

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

@@ -14,5 +14,5 @@ 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("./ProfessionalService.type"), exports);
+__exportStar(require("./ProviderService.type"), exports);
 __exportStar(require("./ServicePricingAndDurationForVehicle.type"), exports);

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

@@ -14,7 +14,7 @@ describe("isValidProfessionalService", () => {
     let isValidServicePricingAndDurationForVehicleReturnValue;
     beforeEach(() => {
         defaultProps = {
-            professionalService: {
+            providerService: {
                 isActive: true,
                 type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                 pricingAndDurationByVehicleType: {
@@ -46,24 +46,24 @@ describe("isValidProfessionalService", () => {
     });
     describe("Active", () => {
         it("should throw if the active field is not a boolean", async () => {
-            defaultProps.professionalService.isActive = "yes";
+            defaultProps.providerService.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;
+            defaultProps.providerService.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";
+            defaultProps.providerService.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;
+            defaultProps.providerService.type = undefined;
             await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
             expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
         });
@@ -82,8 +82,8 @@ describe("isValidProfessionalService", () => {
             await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
             expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
             expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
-                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.professionalService.type],
-                servicePricingAndDurationForVehicle: defaultProps.professionalService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.providerService.type],
+                servicePricingAndDurationForVehicle: defaultProps.providerService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
             });
         });
         it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
@@ -94,7 +94,7 @@ describe("isValidProfessionalService", () => {
     });
     describe("parentsServices", () => {
         it("Should throw if a service does not have the parents services indicated in the config", async () => {
-            defaultProps.professionalService = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [],
@@ -111,7 +111,7 @@ describe("isValidProfessionalService", () => {
             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 = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [
@@ -131,7 +131,7 @@ describe("isValidProfessionalService", () => {
             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 = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
@@ -148,7 +148,7 @@ describe("isValidProfessionalService", () => {
             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 = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [

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

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

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

@@ -0,0 +1,172 @@
+"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 isValidProviderService_1 = require("../isValidProviderService");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+jest.mock("../isValidServicePricingAndDurationForVehicle");
+describe("isValidProviderService", () => {
+    let defaultProps;
+    let isValidServicePricingAndDurationForVehicleMock;
+    let isValidServicePricingAndDurationForVehicleReturnValue;
+    beforeEach(() => {
+        defaultProps = {
+            providerService: {
+                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,
+                    },
+                },
+            },
+            countryServicePublicConfig: (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, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+    });
+    describe("Active", () => {
+        it("should throw if the active field is not a boolean", async () => {
+            defaultProps.providerService.isActive = "yes";
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Provider service isActive 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.providerService.isActive = undefined;
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Provider service isActive 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.providerService.type = "INVALID_TYPE";
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the type is not provided", async () => {
+            defaultProps.providerService.type = undefined;
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Country services public config", () => {
+        it("should throw if there is no public config entry for the provider service type", async () => {
+            defaultProps.countryServicePublicConfig = {};
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Country services public config has no entry for this provider 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, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
+                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.providerService.type],
+                servicePricingAndDurationForVehicle: defaultProps.providerService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+            });
+        });
+        it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = false;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+    });
+    describe("parentsServices", () => {
+        it("Should throw if a service does not have the parents services indicated in the config", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (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, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (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, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (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, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
+            defaultProps.providerService = {
+                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.countryServicePublicConfig = (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, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+    });
+});

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

@@ -12,11 +12,11 @@ describe("isValidServicePricingAndDurationForVehicle", () => {
     let maximumPriceInCents;
     let durationInMinutes;
     beforeEach(() => {
-        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        minimumPriceInCents = constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
         maximumPriceInCents =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
+            constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
         durationInMinutes =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+            constants_1.PROVIDER_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
         defaultProps = {
             servicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
                 byVehicleType: {
@@ -92,16 +92,16 @@ describe("isValidServicePricingAndDurationForVehicle", () => {
     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;
+                constants_1.PROVIDER_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", () => {
+    it("Should return false if pricePreTaxInCents is more than the configured maximum price", () => {
         defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             maximumPriceInCents +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+                constants_1.PROVIDER_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", () => {
+    it("Should return false if pricePreTaxInCents is not a multiple of PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
         defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             maximumPriceInCents - 1;
         expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
@@ -119,13 +119,13 @@ describe("isValidServicePricingAndDurationForVehicle", () => {
     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;
+                constants_1.PROVIDER_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;
+                constants_1.PROVIDER_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", () => {

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

@@ -1,2 +1,2 @@
 export * from "./isValidServicePricingAndDurationForVehicle";
-export * from "./isValidProfessionalService";
+export * from "./isValidProviderService";

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);
             }
         }
     }