@doctocar/tooling 0.3.1-21 → 0.3.1-27

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";
@@ -21,6 +21,7 @@ export * from "./metrics";
 export * from "./onTaskExecutionState";
 export * from "./WithDocumentId.type";
 export * from "./promoCode";
+export * from "./promoCodeRedemptions";
 export * from "./counters";
 export * from "./deviceTokens";
 export * from "./image";
@@ -29,6 +30,8 @@ export * from "./notificationEvent";
 export * from "./wallets";
 export * from "./walletsLedgerEntryDocument";
 export * from "./walletsWithdrawalIntents";
+export * from "./credits";
+export * from "./creditsLedgerEntryDocument";
 export * from "./functionsDeploymentRuns";
 export * from "./marketplaceFinancialReports";
 export * from "./entities";

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);
@@ -37,6 +37,7 @@ __exportStar(require("./metrics"), exports);
 __exportStar(require("./onTaskExecutionState"), exports);
 __exportStar(require("./WithDocumentId.type"), exports);
 __exportStar(require("./promoCode"), exports);
+__exportStar(require("./promoCodeRedemptions"), exports);
 __exportStar(require("./counters"), exports);
 __exportStar(require("./deviceTokens"), exports);
 __exportStar(require("./image"), exports);
@@ -45,6 +46,8 @@ __exportStar(require("./notificationEvent"), exports);
 __exportStar(require("./wallets"), exports);
 __exportStar(require("./walletsLedgerEntryDocument"), exports);
 __exportStar(require("./walletsWithdrawalIntents"), exports);
+__exportStar(require("./credits"), exports);
+__exportStar(require("./creditsLedgerEntryDocument"), exports);
 __exportStar(require("./functionsDeploymentRuns"), exports);
 __exportStar(require("./marketplaceFinancialReports"), exports);
 __exportStar(require("./entities"), 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/order/FirestoreOrderDocument.type.d.ts

@@ -142,6 +142,9 @@ export type FirestoreOrderDocument = {
         status: PaymentStatusTypes;
         amountInCents: number;
         currency: SupportedIsoCurrency;
+        invoiceTotalAmountInCents?: number;
+        creditsUsedInCents?: number;
+        remainingAmountToChargeInCents?: number;
         paidAt?: FirestoreTimestamp;
         authorizedAt?: FirestoreTimestamp;
         capturedAt?: FirestoreTimestamp;

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/promoCode/FirestorePromoCodeDocument.type.d.ts

@@ -1,23 +1,17 @@
-import type { SupportedCountryIsoCodes, SupportedIsoCurrency } from "../../../../enums";
-import type { ServicesTypes, PromoCodeDiscountType } from "../../enums";
+import type { SupportedIsoCurrency } from "../../../../enums";
+import type { PromoCodeDiscountType } from "../../enums";
 import type { FirestoreTimestamp } from "../FirestoreTimestamp.type";
 export type FirestorePromoCodeDocument = {
     code: string;
     active: boolean;
     type: PromoCodeDiscountType;
-    percentOff?: number;
-    amountInCents?: number;
-    currency?: SupportedIsoCurrency;
-    startsAt?: FirestoreTimestamp;
-    endsAt?: FirestoreTimestamp;
-    minOrderAmountInCents?: number;
-    maxRedemptions?: number;
+    amountInCents: number;
+    currency: SupportedIsoCurrency;
+    startsAt: FirestoreTimestamp;
+    endsAt: FirestoreTimestamp;
+    maxRedemptions: number;
     redeemedCount: number;
-    perUserLimit?: number;
-    firstOrderOnly?: boolean;
-    restrictedToServiceTypes?: ServicesTypes[];
-    restrictedToCountries?: SupportedCountryIsoCodes[];
-    stackable?: boolean;
+    firstOrderOnly: boolean;
     createdAt: FirestoreTimestamp;
     updatedAt: FirestoreTimestamp;
 };

package/dist/firebase/firestore/types/promoCodeRedemptions/FirestorePromoCodeRedemptionDocument.type.d.ts

@@ -0,0 +1,9 @@
+import type { FirestoreTimestamp } from "../FirestoreTimestamp.type";
+/**
+ * Per-entity promo redemption counter at
+ * `entities/{entityId}/promo_code_redemptions/{promoCodeId}`.
+ * Document id is the normalized (uppercase) promo code.
+ */
+export type FirestorePromoCodeRedemptionDocument = {
+    redeemedAt: FirestoreTimestamp;
+};

package/dist/firebase/firestore/types/promoCodeRedemptions/FirestorePromoCodeRedemptionDocument.type.js

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

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

@@ -0,0 +1 @@
+export * from "./FirestorePromoCodeRedemptionDocument.type";

package/dist/firebase/firestore/types/promoCodeRedemptions/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("./FirestorePromoCodeRedemptionDocument.type"), exports);

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