@doctocar/tooling 0.3.1-34 → 0.3.1-36

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

@@ -1,3 +1,4 @@
+import type { SupportedIsoCurrency } from "../../../../enums";
 import type { FirestoreOpType, OrderInvoiceGenerationStatus, OrderIssueSeverityLevel, OrderStatusTypes } from "../../enums";
 import type { FirestoreTimestamp } from "../FirestoreTimestamp.type";
 import type { DoctoCarLocation } from "../location";
@@ -44,6 +45,7 @@ export type FirestoreOrderDocument = {
         serviceCompletedAt?: FirestoreTimestamp;
         issueReportedByCustomerAt?: FirestoreTimestamp;
         completedAt?: FirestoreTimestamp;
+        invoicedAt?: FirestoreTimestamp;
         cancelledAt?: FirestoreTimestamp;
     };
     publicReference: string;
@@ -138,8 +140,10 @@ export type FirestoreOrderDocument = {
     };
     execution?: {
         serviceProviderEntityWalletCredit?: {
-            walletLedgerEntryId?: string;
-            creditedAt?: FirestoreTimestamp;
+            walletLedgerEntryId: string;
+            creditedAt: FirestoreTimestamp;
+            amountInCents: number;
+            currency: SupportedIsoCurrency;
         };
     };
     metadata?: Record<string, string>;

package/dist/firebase/firestore/utils/dataValidators/slots/__tests__/isValidOneTimeSlot.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/slots/__tests__/isValidOneTimeSlot.test.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const constants_1 = require("../../../../../../constants");
+const constants_2 = require("../../../../constants");
+const enums_1 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const constants_3 = require("../constants");
+const isValidOneTimeSlot_1 = require("../isValidOneTimeSlot");
+describe("isValidOneTimeSlot", () => {
+    const baseValidSlot = {
+        type: enums_1.SlotType.ONE_TIME,
+        capacity: 3,
+        createdAt: (0, stubs_1.firestoreTimestampStub)(),
+        updatedAt: (0, stubs_1.firestoreTimestampStub)(),
+        timeZone: "Europe/Paris",
+    };
+    beforeEach(() => {
+        jest
+            .useFakeTimers()
+            .setSystemTime(new Date("2024-01-01T12:00:00Z").getTime());
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it("returns true for a valid slot", () => {
+        const slot = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(slot)).toBe(true);
+    });
+    it("return true for differents valid timezones", () => {
+        const validTimezones = [
+            "Europe/Paris",
+            "Europe/Berlin",
+            "Europe/Madrid",
+            "Europe/Rome",
+            "Europe/Brussels",
+            "Europe/Moscow",
+            "America/New_York",
+            "Asia/Tokyo",
+            "Australia/Sydney",
+            "UTC",
+            "Europe/London",
+            "America/Los_Angeles",
+            "Asia/Kolkata",
+            "America/Argentina/Buenos_Aires",
+            "Asia/Shanghai",
+        ];
+        validTimezones.forEach((timezone) => {
+            const slot = {
+                ...baseValidSlot,
+                timeZone: timezone,
+                timestampRange: {
+                    startAt: (0, stubs_1.firestoreTimestampStub)({
+                        toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                    }),
+                    endAt: (0, stubs_1.firestoreTimestampStub)({
+                        toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                    }),
+                },
+            };
+            expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(slot)).toBe(true);
+        });
+    });
+    it("return false if timeZone is missing or invalid", () => {
+        const missingTimeZone = {
+            ...baseValidSlot,
+            timeZone: undefined,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(missingTimeZone)).toBe(false);
+        const slot = {
+            ...baseValidSlot,
+            timeZone: "",
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(slot)).toBe(false);
+        const invalidSlot = {
+            ...baseValidSlot,
+            timeZone: "Invalid/Timezone",
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(invalidSlot)).toBe(false);
+    });
+    it("return false if type is not ONE_TIME", () => {
+        const slot = {
+            ...baseValidSlot,
+            type: enums_1.SlotType.RECURRING,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => 0,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => 1,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(slot)).toBe(false);
+    });
+    it("return false if timestampRange, startAt or endAt is missing", () => {
+        const missingTimeRange = {
+            ...baseValidSlot,
+            timestampRange: undefined,
+        };
+        const missingStart = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: undefined,
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+            },
+        };
+        const missingEnd = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+                endAt: undefined,
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(missingTimeRange)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(missingStart)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(missingEnd)).toBe(false);
+    });
+    it("return false if capacity is not an integer ≥ 1 <= MAXIMUM_SLOT_CAPACITY", () => {
+        const zeroCap = {
+            ...baseValidSlot,
+            capacity: 0,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        const negCap = {
+            ...baseValidSlot,
+            capacity: -5,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        const floatCap = {
+            ...baseValidSlot,
+            capacity: 2.5,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        const tooBigCap = {
+            ...baseValidSlot,
+            capacity: constants_2.MAXIMUM_SLOT_CAPACITY + 1,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(zeroCap)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(negCap)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(floatCap)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(tooBigCap)).toBe(false);
+    });
+    it("return false if startAt or endAt does not have toMillis()", () => {
+        const badStart = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: { toMillis: undefined },
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => 1,
+                }),
+            },
+        };
+        const badEnd = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => 0,
+                }),
+                endAt: { toMillis: undefined },
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(badStart)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(badEnd)).toBe(false);
+    });
+    it("return false if startAt ≥ endAt", () => {
+        const equalTimes = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+            },
+        };
+        const backwards = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(equalTimes)).toBe(false);
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(backwards)).toBe(false);
+    });
+    it("return false if startAt is in the past", () => {
+        const pastStart = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() - constants_1.ONE_HOUR_IN_MS,
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => Date.now() + constants_1.ONE_HOUR_IN_MS,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(pastStart)).toBe(false);
+    });
+    it("return false if endAt is more than MAX_ year in the future", () => {
+        const farFuture = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => Date.now(),
+                }),
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => Date.now() + constants_3.MAX_SLOT_END_DATE_IN_MS + constants_1.ONE_DAY_IN_MS,
+                }),
+            },
+        };
+        expect((0, isValidOneTimeSlot_1.isValidOneTimeSlot)(farFuture)).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/slots/__tests__/isValidRecurringSlot.test.d.ts

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