@doctocar/tooling 0.3.1-16 → 0.3.1-17

package/dist/firebase/firestore/utils/users/__tests__/assertProfessionalUserIsBookable.util.test.js

@@ -0,0 +1,400 @@
+"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 dataValidators_1 = require("../../dataValidators");
+const stubs_1 = require("../../stubs");
+const assertProfessionalUserIsBookable_util_1 = require("../assertProfessionalUserIsBookable.util");
+jest.mock("../../dataValidators", () => ({
+    ...jest.requireActual("../../dataValidators"),
+    isCompanyVatValid: jest.fn(),
+    isLegalAddressValid: jest.fn(),
+    isFrenchCompanyRegistrationValid: jest.fn(),
+}));
+const validProfessionalInfos = firestoreUserDocumentProfessionalInfosStub({
+    privacyPolicyPro: {
+        acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
+        version: "1.0.0",
+    },
+    termsOfService: {
+        acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
+        version: "1.0.0",
+    },
+    companyDetails: (0, stubs_1.professionalCompanyDetailsStub)({}),
+    stripe: {
+        accountId: "acct_123",
+        chargesEnabled: true,
+        payoutsEnabled: true,
+        detailsSubmitted: true,
+    },
+});
+const validProfessionalUserDocument = (0, stubs_1.firestoreUserDocumentStub)({
+    isTest: false,
+    professionalInfos: validProfessionalInfos,
+});
+const validProfessionalUserPublicDocument = (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+    isBookable: true,
+    isTest: false,
+    activeServicesVehiclesCombos: ["service1-vehicle1", "service2-vehicle2"],
+});
+const platformPublicConfigDocument = (0, stubs_1.firestorePlatformPublicConfigDocumentStub)({
+    data: {
+        legal: {
+            privacyPolicy: {
+                version: "1.0.0",
+                documentUrl: "https://example.com/privacy-policy",
+            },
+            privacyPolicyPro: {
+                version: "1.0.0",
+                documentUrl: "https://example.com/privacy-policy-pro",
+            },
+            marketplaceTermsPro: {
+                version: "1.0.0",
+                documentUrl: "https://example.com/marketplace-terms-pro",
+            },
+            selfBillingAgreement: {
+                version: "1.0.0",
+                documentUrl: "https://example.com/self-billing-agreement",
+            },
+            marketplaceTerms: {
+                version: "1.0.0",
+                documentUrl: "https://example.com/marketplace-terms",
+            },
+        },
+    },
+});
+const successCases = [
+    {
+        name: "valid professional user",
+        professionalUserDocument: validProfessionalUserDocument,
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        only: false,
+    },
+    {
+        name: "valid professional Test user with no stripe",
+        only: false,
+        professionalUserDocument: {
+            ...validProfessionalUserDocument,
+            isTest: true,
+            professionalInfos: firestoreUserDocumentProfessionalInfosStub({
+                ...validProfessionalUserDocument.professionalInfos,
+                stripe: undefined,
+            }),
+        },
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+    },
+];
+const errorCases = [
+    {
+        name: "missing privacy policy acceptance",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: {
+                ...validProfessionalInfos,
+                privacyPolicyPro: { acceptedAt: undefined, version: "1.0.0" },
+            },
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY),
+    },
+    {
+        name: "Invalid privacy policy acceptance version",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: {
+                ...validProfessionalInfos,
+                privacyPolicyPro: {
+                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
+                    version: "0.1.0",
+                },
+            },
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY),
+    },
+    {
+        name: "Invalid if privacyPolicyPro version is newer",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: {
+                ...validProfessionalInfos,
+                privacyPolicyPro: {
+                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
+                    version: "2.0.0",
+                },
+            },
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY),
+    },
+    {
+        name: "Invalid if termsOfService version is newer",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: {
+                ...validProfessionalInfos,
+                termsOfService: {
+                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
+                    version: "2.0.0",
+                },
+            },
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest marketplace terms", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE),
+    },
+    {
+        name: "missing terms of service acceptance",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: {
+                ...validProfessionalInfos,
+                termsOfService: { acceptedAt: undefined, version: "1.0.0" },
+            },
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest marketplace terms", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE),
+    },
+    {
+        name: "Invalid terms of service acceptance",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: {
+                ...validProfessionalInfos,
+                termsOfService: {
+                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
+                    version: "0.1.0",
+                },
+            },
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest marketplace terms", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE),
+    },
+    {
+        name: "invalid company VAT details",
+        only: false,
+        professionalUserDocument: validProfessionalUserDocument,
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: false,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user company VAT details are not valid", enums_2.ProfessionalNonBookableReason.COMPANY_VAT_DETAILS_ARE_NOT_VALID),
+    },
+    {
+        name: "invalid legal address",
+        only: false,
+        professionalUserDocument: validProfessionalUserDocument,
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: false,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user legal address is not valid", enums_2.ProfessionalNonBookableReason.COMPANY_LEGAL_ADDRESS_IS_NOT_VALID),
+    },
+    {
+        name: "Stripe account not configured for non-test user",
+        only: false,
+        professionalUserDocument: {
+            ...validProfessionalUserDocument,
+            isTest: false,
+            professionalInfos: firestoreUserDocumentProfessionalInfosStub({
+                ...validProfessionalUserDocument.professionalInfos,
+                stripe: undefined,
+            }),
+        },
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user Stripe account is not properly configured", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_NOT_CONFIGURED),
+    },
+    {
+        name: "Stripe account hasDiscrepancyWithFirestore true for non-test user",
+        only: false,
+        professionalUserDocument: {
+            ...validProfessionalUserDocument,
+            isTest: false,
+            professionalInfos: firestoreUserDocumentProfessionalInfosStub({
+                ...validProfessionalUserDocument.professionalInfos,
+                stripe: {
+                    accountId: "acct_123",
+                    chargesEnabled: true,
+                    payoutsEnabled: true,
+                    detailsSubmitted: true,
+                    hasDiscrepancyWithFirestore: true,
+                },
+            }),
+        },
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Mismatch between Stripe account details and Firestore professional infos", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_HAS_DISCREPANCY_WITH_FIRESTORE),
+    },
+    {
+        name: "No active services vehicles combos",
+        only: false,
+        professionalUserDocument: validProfessionalUserDocument,
+        professionalUserPublicDocument: {
+            ...validProfessionalUserPublicDocument,
+            activeServicesVehiclesCombos: [],
+        },
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user has no active services or vehicles combos", enums_2.ProfessionalNonBookableReason.USER_HAS_NO_ACTIVE_SERVICES_VEHICLES_COMBOS),
+    },
+    {
+        name: "Unsupported country",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: firestoreUserDocumentProfessionalInfosStub({
+                ...validProfessionalInfos,
+                companyDetails: (0, stubs_1.professionalCompanyDetailsStub)({
+                    legalAddress: {
+                        ...validProfessionalInfos.companyDetails.legalAddress,
+                        country: "unsupported",
+                    },
+                    registration: {
+                        FR: validProfessionalInfos.companyDetails.registration.FR,
+                    },
+                }),
+            }),
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: true,
+        expectedError: new errors_1.DoctoCarError("Professional user country 'unsupported' is not supported", enums_2.ProfessionalNonBookableReason.COUNTRY_IS_NOT_SUPPORTED),
+    },
+    {
+        name: "Invalid French company registration",
+        only: false,
+        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
+            isTest: false,
+            professionalInfos: firestoreUserDocumentProfessionalInfosStub({
+                ...validProfessionalInfos,
+                companyDetails: (0, stubs_1.professionalCompanyDetailsStub)({
+                    legalAddress: {
+                        ...validProfessionalInfos.companyDetails.legalAddress,
+                        country: enums_1.SupportedCountryIsoCodes.FRANCE,
+                    },
+                    registration: {},
+                }),
+            }),
+        }),
+        professionalUserPublicDocument: validProfessionalUserPublicDocument,
+        platformPublicConfigDocument,
+        isCompanyVatValidReturnValue: true,
+        isLegalAddressValidReturnValue: true,
+        isFrenchCompanyRegistrationValidReturnValue: false,
+        expectedError: new errors_1.DoctoCarError(`Professional user company registration details for country '${enums_1.SupportedCountryIsoCodes.FRANCE}' are not valid`, enums_2.ProfessionalNonBookableReason.COMPANY_REGISTRATION_DETAILS_ARE_NOT_VALID),
+    },
+];
+const hasOnly = errorCases.some((c) => c.only);
+const filteredErrorCases = hasOnly
+    ? errorCases.filter((c) => c.only)
+    : errorCases;
+describe("assertProfessionalUserIsBookable", () => {
+    let isCompanyVatValidMock;
+    let isLegalAddressValidMock;
+    let isFrenchCompanyRegistrationValidMock;
+    beforeEach(() => {
+        isCompanyVatValidMock = dataValidators_1.isCompanyVatValid;
+        isLegalAddressValidMock = dataValidators_1.isLegalAddressValid;
+        isFrenchCompanyRegistrationValidMock =
+            dataValidators_1.isFrenchCompanyRegistrationValid;
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("success cases", () => {
+        test.each(successCases)("should NOT throw if $name", ({ professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument, isCompanyVatValidReturnValue, isLegalAddressValidReturnValue, isFrenchCompanyRegistrationValidReturnValue, }) => {
+            isCompanyVatValidMock.mockReturnValue(isCompanyVatValidReturnValue);
+            isLegalAddressValidMock.mockReturnValue(isLegalAddressValidReturnValue);
+            isFrenchCompanyRegistrationValidMock.mockReturnValue(isFrenchCompanyRegistrationValidReturnValue);
+            try {
+                (0, assertProfessionalUserIsBookable_util_1.assertProfessionalUserIsBookable)(professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument);
+                expect(isCompanyVatValidMock).toHaveBeenCalledTimes(1);
+                expect(isCompanyVatValidMock).toHaveBeenCalledWith(professionalUserDocument.professionalInfos.companyDetails
+                    .vatDetails);
+                expect(isLegalAddressValidMock).toHaveBeenCalledTimes(1);
+                expect(isLegalAddressValidMock).toHaveBeenCalledWith(professionalUserDocument.professionalInfos.companyDetails
+                    .legalAddress);
+                expect(isFrenchCompanyRegistrationValidMock).toHaveBeenCalledTimes(1);
+                expect(isFrenchCompanyRegistrationValidMock).toHaveBeenCalledWith({
+                    registration: professionalUserDocument.professionalInfos.companyDetails
+                        .registration.FR,
+                });
+            }
+            catch (e) {
+                throw new Error(`validateSelectedProfessionalsServiceTypesOrThrow should not throw, but it did: ${e}`);
+            }
+        });
+    });
+    describe("error cases", () => {
+        test.each(filteredErrorCases)("should throw if $name", ({ professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument, isCompanyVatValidReturnValue, isLegalAddressValidReturnValue, expectedError, isFrenchCompanyRegistrationValidReturnValue, }) => {
+            isCompanyVatValidMock.mockReturnValue(isCompanyVatValidReturnValue);
+            isLegalAddressValidMock.mockReturnValue(isLegalAddressValidReturnValue);
+            isFrenchCompanyRegistrationValidMock.mockReturnValue(isFrenchCompanyRegistrationValidReturnValue);
+            try {
+                (0, assertProfessionalUserIsBookable_util_1.assertProfessionalUserIsBookable)(professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument);
+                throw new Error("assertProfessionalUserIsBookable did not throw");
+            }
+            catch (error) {
+                if (error instanceof errors_1.DoctoCarError) {
+                    expect(error.message).toBe(expectedError?.message);
+                    expect(error.errorCode).toBe(expectedError?.errorCode);
+                }
+                else {
+                    throw new Error(`Expected DoctoCarError, but got: ${error}`);
+                }
+            }
+        });
+    });
+});

package/dist/firebase/firestore/utils/users/assertCustomerUserCanBookServices.d.ts

@@ -0,0 +1,3 @@
+import type { FirestorePlatformPublicConfigDocument, FirestoreUserDocument } from "../../types";
+import type { BookingReadyCustomerUserDocument } from "./types";
+export declare function assertCustomerUserCanBookServices(customerUserDocument: FirestoreUserDocument, platformConfigDocument: FirestorePlatformPublicConfigDocument): asserts customerUserDocument is BookingReadyCustomerUserDocument;

package/dist/firebase/firestore/utils/users/assertCustomerUserCanBookServices.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertCustomerUserCanBookServices = assertCustomerUserCanBookServices;
+function assertCustomerUserCanBookServices(customerUserDocument, platformConfigDocument) {
+    // if (
+    //   customerUserDocument.customerInfos?.privacyPolicy?.acceptedAt ===
+    //     undefined ||
+    //   customerUserDocument.customerInfos?.privacyPolicy.version === undefined ||
+    //   !semver.eq(
+    //     customerUserDocument.customerInfos?.privacyPolicy.version,
+    //     platformConfigDocument.data.legal.privacyPolicy.version,
+    //   )
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Customer user has not accepted the latest privacy policy",
+    //     AssertCustomerUserCanBookServicesErrorCodes.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY,
+    //   );
+    // }
+    // if (
+    //   customerUserDocument.customerInfos?.termsOfUse?.acceptedAt === undefined ||
+    //   customerUserDocument.customerInfos?.termsOfUse.version === undefined ||
+    //   !semver.eq(
+    //     customerUserDocument.customerInfos?.termsOfUse.version,
+    //     platformConfigDocument.data.legal.marketplaceTerms.version,
+    //   )
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Customer user has not accepted the latest marketplace terms",
+    //     AssertCustomerUserCanBookServicesErrorCodes.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE,
+    //   );
+    // }
+    // if (
+    //   isLegalAddressValid(customerUserDocument.customerInfos.billingAddress) ===
+    //   false
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Customer user billing address is not valid",
+    //     AssertCustomerUserCanBookServicesErrorCodes.BILLING_ADDRESS_IS_NOT_VALID,
+    //   );
+    // }
+    // if (
+    //   customerUserDocument.customerInfos.customerAccountType ===
+    //   CustomerAccountTypes.BUSINESS
+    // ) {
+    //   if (
+    //     !customerUserDocument.customerInfos.companyDetails?.legalAddress ||
+    //     isLegalAddressValid(
+    //       customerUserDocument.customerInfos.companyDetails.legalAddress,
+    //     ) === false
+    //   ) {
+    //     throw new DoctoCarError(
+    //       "Customer user company legal address is not valid",
+    //       AssertCustomerUserCanBookServicesErrorCodes.LEGAL_ADDRESS_IS_NOT_VALID,
+    //     );
+    //   }
+    // }
+}
+// TODO remove this file as now it is entity customer related

package/dist/firebase/firestore/utils/users/assertProfessionalUserIsBookable.util.d.ts

@@ -0,0 +1,3 @@
+import type { FirestorePlatformPublicConfigDocument, FirestoreProfessionalUserPublicDocument, FirestoreUserDocument } from "../../types";
+import type { BookableProfessionalUserDocument } from "./types";
+export declare function assertProfessionalUserIsBookable(professionalUserDocument: FirestoreUserDocument, professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument, platformPublicConfigDocument: FirestorePlatformPublicConfigDocument): asserts professionalUserDocument is BookableProfessionalUserDocument;

package/dist/firebase/firestore/utils/users/assertProfessionalUserIsBookable.util.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertProfessionalUserIsBookable = assertProfessionalUserIsBookable;
+function assertProfessionalUserIsBookable(professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument) {
+    // if (
+    //   professionalUserDocument.professionalInfos?.privacyPolicyPro?.acceptedAt ===
+    //     undefined ||
+    //   professionalUserDocument.professionalInfos?.privacyPolicyPro?.version ===
+    //     undefined ||
+    //   !semver.eq(
+    //     professionalUserDocument.professionalInfos?.privacyPolicyPro.version,
+    //     platformPublicConfigDocument.data.legal.privacyPolicyPro.version,
+    //   )
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Professional user has not accepted the latest privacy policy",
+    //     ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY,
+    //   );
+    // }
+    // if (
+    //   professionalUserDocument.professionalInfos?.termsOfService?.acceptedAt ===
+    //     undefined ||
+    //   professionalUserDocument.professionalInfos?.termsOfService?.version ===
+    //     undefined ||
+    //   !semver.eq(
+    //     professionalUserDocument.professionalInfos?.termsOfService.version,
+    //     platformPublicConfigDocument.data.legal.marketplaceTermsPro.version,
+    //   )
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Professional user has not accepted the latest marketplace terms",
+    //     ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE,
+    //   );
+    // }
+    // if (
+    //   !professionalUserDocument.professionalInfos?.companyDetails.vatDetails ||
+    //   isCompanyVatValid(
+    //     professionalUserDocument.professionalInfos?.companyDetails.vatDetails,
+    //   ) === false
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Professional user company VAT details are not valid",
+    //     ProfessionalNonBookableReason.COMPANY_VAT_DETAILS_ARE_NOT_VALID,
+    //   );
+    // }
+    // if (
+    //   isLegalAddressValid(
+    //     professionalUserDocument.professionalInfos.companyDetails.legalAddress,
+    //   ) === false
+    // ) {
+    //   throw new DoctoCarError(
+    //     "Professional user legal address is not valid",
+    //     ProfessionalNonBookableReason.COMPANY_LEGAL_ADDRESS_IS_NOT_VALID,
+    //   );
+    // }
+    // const legalCountry =
+    //   professionalUserDocument.professionalInfos.companyDetails.legalAddress
+    //     .country;
+    // switch (legalCountry) {
+    //   case SupportedCountryIsoCodes.FRANCE: {
+    //     const companyRegistration =
+    //       professionalUserDocument.professionalInfos.companyDetails.registration[
+    //         legalCountry
+    //       ];
+    //     if (
+    //       !companyRegistration ||
+    //       !isFrenchCompanyRegistrationValid({ registration: companyRegistration })
+    //     ) {
+    //       throw new DoctoCarError(
+    //         `Professional user company registration details for country '${legalCountry}' are not valid`,
+    //         ProfessionalNonBookableReason.COMPANY_REGISTRATION_DETAILS_ARE_NOT_VALID,
+    //       );
+    //     }
+    //     break;
+    //   }
+    //   default:
+    //     throw new DoctoCarError(
+    //       `Professional user country '${legalCountry}' is not supported`,
+    //       ProfessionalNonBookableReason.COUNTRY_IS_NOT_SUPPORTED,
+    //     );
+    // }
+    // if (professionalUserDocument.isTest !== true) {
+    //   const stripe = professionalUserDocument.professionalInfos?.stripe;
+    //   if (!stripe) {
+    //     throw new DoctoCarError(
+    //       "Professional user Stripe account is not properly configured",
+    //       ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_NOT_CONFIGURED,
+    //     );
+    //   }
+    //   if (
+    //     !stripe.accountId ||
+    //     !stripe.chargesEnabled ||
+    //     !stripe.payoutsEnabled ||
+    //     !stripe.detailsSubmitted
+    //   ) {
+    //     throw new DoctoCarError(
+    //       "Professional user Stripe account is not properly configured",
+    //       ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_NOT_CONFIGURED,
+    //     );
+    //   }
+    //   if (stripe.hasDiscrepancyWithFirestore === true) {
+    //     throw new DoctoCarError(
+    //       "Mismatch between Stripe account details and Firestore professional infos",
+    //       ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_HAS_DISCREPANCY_WITH_FIRESTORE,
+    //     );
+    //   }
+    // }
+    // if (professionalUserPublicDocument.activeServicesVehiclesCombos.length < 1) {
+    //   throw new DoctoCarError(
+    //     "Professional user has no active services or vehicles combos",
+    //     ProfessionalNonBookableReason.USER_HAS_NO_ACTIVE_SERVICES_VEHICLES_COMBOS,
+    //   );
+    // }
+}
+// TODO remove this file as now it is entity professional related

package/dist/firebase/firestore/utils/users/errors/enums/AssertCustomerUserCanBookServicesErrorCodes.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum AssertCustomerUserCanBookServicesErrorCodes {
+    USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY = "USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY",
+    USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE = "USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE",
+    BILLING_ADDRESS_IS_NOT_VALID = "BILLING_ADDRESS_IS_NOT_VALID",
+    LEGAL_ADDRESS_IS_NOT_VALID = "LEGAL_ADDRESS_IS_NOT_VALID",
+    USER_ONBOARDING_NOT_COMPLETED = "USER_ONBOARDING_NOT_COMPLETED"
+}

package/dist/firebase/firestore/utils/users/errors/enums/AssertCustomerUserCanBookServicesErrorCodes.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertCustomerUserCanBookServicesErrorCodes = void 0;
+var AssertCustomerUserCanBookServicesErrorCodes;
+(function (AssertCustomerUserCanBookServicesErrorCodes) {
+    AssertCustomerUserCanBookServicesErrorCodes["USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY"] = "USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY";
+    AssertCustomerUserCanBookServicesErrorCodes["USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE"] = "USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE";
+    AssertCustomerUserCanBookServicesErrorCodes["BILLING_ADDRESS_IS_NOT_VALID"] = "BILLING_ADDRESS_IS_NOT_VALID";
+    AssertCustomerUserCanBookServicesErrorCodes["LEGAL_ADDRESS_IS_NOT_VALID"] = "LEGAL_ADDRESS_IS_NOT_VALID";
+    AssertCustomerUserCanBookServicesErrorCodes["USER_ONBOARDING_NOT_COMPLETED"] = "USER_ONBOARDING_NOT_COMPLETED";
+})(AssertCustomerUserCanBookServicesErrorCodes || (exports.AssertCustomerUserCanBookServicesErrorCodes = AssertCustomerUserCanBookServicesErrorCodes = {}));

package/dist/firebase/firestore/utils/users/errors/enums/index.d.ts

@@ -0,0 +1 @@
+export * from "./AssertCustomerUserCanBookServicesErrorCodes.enum";

package/dist/firebase/firestore/utils/users/errors/enums/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("./AssertCustomerUserCanBookServicesErrorCodes.enum"), exports);

package/dist/firebase/firestore/utils/users/errors/index.d.ts

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

package/dist/firebase/firestore/utils/users/errors/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("./enums"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./assertCustomerUserCanBookServices";
+export * from "./assertProfessionalUserIsBookable.util";
+export * from "./types";