@doctocar/tooling 0.3.1-34 → 0.3.1-35

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

@@ -0,0 +1,272 @@
+"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 isValidTimeOffSlot_1 = require("../isValidTimeOffSlot");
+describe("isValidTimeOffSlot", () => {
+    const baseValidSlot = {
+        type: enums_1.SlotType.TIME_OFF,
+        capacity: 3,
+        createdAt: (0, stubs_1.firestoreTimestampStub)(),
+        updatedAt: (0, stubs_1.firestoreTimestampStub)(),
+        timeZone: "Europe/Paris",
+    };
+    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, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(invalidSlot)).toBe(false);
+    });
+    it("return false if type is not TIME_OFF", () => {
+        const slot = {
+            ...baseValidSlot,
+            type: enums_1.SlotType.RECURRING,
+            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, isValidTimeOffSlot_1.isValidTimeOffSlot)(slot)).toBe(false);
+    });
+    it("return false if startAt or endAt is missing", () => {
+        const missingStart = {
+            ...baseValidSlot,
+            timestampRange: {
+                endAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS * 2,
+                }),
+            },
+        };
+        const missingEnd = {
+            ...baseValidSlot,
+            timestampRange: {
+                startAt: (0, stubs_1.firestoreTimestampStub)({
+                    toMillis: () => new Date().getTime() + constants_1.ONE_HOUR_IN_MS,
+                }),
+            },
+        };
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(missingStart)).toBe(false);
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(zeroCap)).toBe(false);
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(negCap)).toBe(false);
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(floatCap)).toBe(false);
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(badStart)).toBe(false);
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(equalTimes)).toBe(false);
+        expect((0, isValidTimeOffSlot_1.isValidTimeOffSlot)(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, isValidTimeOffSlot_1.isValidTimeOffSlot)(pastStart)).toBe(false);
+    });
+    it("return false if endAt is more than MAX_SLOT_END_DATE_IN_MS 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, isValidTimeOffSlot_1.isValidTimeOffSlot)(farFuture)).toBe(false);
+    });
+});

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

@@ -1,3 +1,3 @@
-export * from "./isValidOneTimeSlot.util";
-export * from "./isValidRecurringSlot.util";
-export * from "./isValidTimeOffSlot.util";
+export * from "./isValidOneTimeSlot";
+export * from "./isValidRecurringSlot";
+export * from "./isValidTimeOffSlot";

package/dist/firebase/firestore/utils/dataValidators/slots/index.js

@@ -14,6 +14,6 @@ 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("./isValidOneTimeSlot.util"), exports);
-__exportStar(require("./isValidRecurringSlot.util"), exports);
-__exportStar(require("./isValidTimeOffSlot.util"), exports);
+__exportStar(require("./isValidOneTimeSlot"), exports);
+__exportStar(require("./isValidRecurringSlot"), exports);
+__exportStar(require("./isValidTimeOffSlot"), exports);

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidOneTimeSlot = isValidOneTimeSlot;
+const constants_1 = require("../../../constants");
+const enums_1 = require("../../../enums");
+const constants_2 = require("./constants");
+function isValidOneTimeSlot(oneTimeSlot) {
+    if (oneTimeSlot.type !== enums_1.SlotType.ONE_TIME) {
+        return false;
+    }
+    if (!oneTimeSlot.timestampRange ||
+        !oneTimeSlot.timestampRange.startAt ||
+        !oneTimeSlot.timestampRange.endAt ||
+        !oneTimeSlot.timeZone) {
+        return false;
+    }
+    if (typeof oneTimeSlot.timeZone !== "string" ||
+        oneTimeSlot.timeZone.trim() === "") {
+        return false;
+    }
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: oneTimeSlot.timeZone });
+    }
+    catch (error) {
+        return false;
+    }
+    if (!Number.isInteger(oneTimeSlot.capacity) ||
+        oneTimeSlot.capacity < 1 ||
+        oneTimeSlot.capacity > constants_1.MAXIMUM_SLOT_CAPACITY) {
+        return false;
+    }
+    if (!oneTimeSlot.timestampRange.startAt.toMillis ||
+        !oneTimeSlot.timestampRange.endAt.toMillis) {
+        return false;
+    }
+    const startAtInMs = oneTimeSlot.timestampRange.startAt.toMillis();
+    const endAtInMs = oneTimeSlot.timestampRange.endAt.toMillis();
+    const nowInMs = Date.now();
+    if (startAtInMs >= endAtInMs ||
+        startAtInMs < nowInMs ||
+        endAtInMs > constants_2.MAX_SLOT_END_DATE_IN_MS) {
+        return false;
+    }
+    return true;
+}

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

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

package/dist/firebase/firestore/utils/dataValidators/slots/isValidRecurringSlot.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidRecurringSlot = isValidRecurringSlot;
+const enums_1 = require("../../../../../enums");
+const constants_1 = require("../../../constants");
+const enums_2 = require("../../../enums");
+function isValidRecurringSlot(recurringSlot) {
+    if (recurringSlot.type !== enums_2.SlotType.RECURRING) {
+        return false;
+    }
+    const requiredFields = [
+        recurringSlot.localTimeRangeOfDay,
+        recurringSlot.localTimeRangeOfDay?.startTime,
+        recurringSlot.localTimeRangeOfDay?.endTime,
+        recurringSlot.startDate,
+        recurringSlot.timeZone,
+        recurringSlot.intervalWeeks,
+    ];
+    if (requiredFields.some((f) => f == null)) {
+        return false;
+    }
+    if (typeof recurringSlot.timeZone !== "string" ||
+        recurringSlot.timeZone.trim() === "") {
+        return false;
+    }
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: recurringSlot.timeZone });
+    }
+    catch (error) {
+        return false;
+    }
+    if (!Number.isInteger(recurringSlot.capacity) ||
+        recurringSlot.capacity < 1 ||
+        recurringSlot.capacity > constants_1.MAXIMUM_SLOT_CAPACITY) {
+        return false;
+    }
+    const uniqueDaysOfWeek = Array.from(new Set(recurringSlot.daysOfWeek));
+    if (uniqueDaysOfWeek.length !== recurringSlot.daysOfWeek.length ||
+        uniqueDaysOfWeek.length === 0) {
+        return false;
+    }
+    if (!uniqueDaysOfWeek.every((d) => Object.values(enums_1.WeekDays).includes(d))) {
+        return false;
+    }
+    if (!recurringSlot.startDate.toMillis ||
+        isNaN(recurringSlot.startDate.toMillis())) {
+        return false;
+    }
+    if (recurringSlot.endDate) {
+        if (typeof recurringSlot.endDate.toMillis !== "function" ||
+            isNaN(recurringSlot.endDate.toMillis())) {
+            return false;
+        }
+        if (recurringSlot.endDate.toMillis() <= recurringSlot.startDate.toMillis()) {
+            return false;
+        }
+    }
+    for (const field of ["startTime", "endTime"]) {
+        const time = recurringSlot.localTimeRangeOfDay[field];
+        if (time == null ||
+            !Number.isInteger(time.hour) ||
+            !Number.isInteger(time.minute) ||
+            time.hour < 0 ||
+            time.hour > 23 ||
+            time.minute < 0 ||
+            time.minute > 59) {
+            return false;
+        }
+    }
+    const startMinutes = recurringSlot.localTimeRangeOfDay.startTime.hour * 60 +
+        recurringSlot.localTimeRangeOfDay.startTime.minute;
+    const endMinutes = recurringSlot.localTimeRangeOfDay.endTime.hour * 60 +
+        recurringSlot.localTimeRangeOfDay.endTime.minute;
+    if (endMinutes <= startMinutes) {
+        return false;
+    }
+    if (!Number.isInteger(recurringSlot.intervalWeeks) ||
+        recurringSlot.intervalWeeks < 1 ||
+        recurringSlot.intervalWeeks > 52) {
+        return false;
+    }
+    return true;
+}

package/dist/firebase/firestore/utils/dataValidators/slots/isValidTimeOffSlot.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/slots/isValidTimeOffSlot.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidTimeOffSlot = isValidTimeOffSlot;
+const constants_1 = require("../../../constants");
+const enums_1 = require("../../../enums");
+const constants_2 = require("./constants");
+function isValidTimeOffSlot(timeOffSlot) {
+    if (timeOffSlot.type !== enums_1.SlotType.TIME_OFF) {
+        return false;
+    }
+    if (!timeOffSlot.timestampRange ||
+        !timeOffSlot.timestampRange.startAt ||
+        !timeOffSlot.timestampRange.endAt ||
+        !timeOffSlot.timeZone) {
+        return false;
+    }
+    if (typeof timeOffSlot.timeZone !== "string" ||
+        timeOffSlot.timeZone.trim() === "") {
+        return false;
+    }
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: timeOffSlot.timeZone });
+    }
+    catch (error) {
+        return false;
+    }
+    if (!Number.isInteger(timeOffSlot.capacity) ||
+        timeOffSlot.capacity < 1 ||
+        timeOffSlot.capacity > constants_1.MAXIMUM_SLOT_CAPACITY) {
+        return false;
+    }
+    if (!timeOffSlot.timestampRange.startAt.toMillis ||
+        !timeOffSlot.timestampRange.endAt.toMillis) {
+        return false;
+    }
+    const startAtInMs = timeOffSlot.timestampRange.startAt.toMillis();
+    const endAtInMs = timeOffSlot.timestampRange.endAt.toMillis();
+    const nowInMs = Date.now();
+    if (startAtInMs >= endAtInMs ||
+        startAtInMs < nowInMs ||
+        endAtInMs > constants_2.MAX_SLOT_END_DATE_IN_MS) {
+        return false;
+    }
+    return true;
+}

package/dist/gcp/pubsub/enums/PubSubTopics.enum.d.ts

@@ -8,7 +8,7 @@ export declare enum PubSubTopics {
     ORDER_PAYMENT_SUCCEEDED = "order-payment-succeeded",
     ORDER_PAYMENT_FAILED = "order-payment-failed",
     ORDER_PAYMENT_CANCELED = "order-payment-canceled",
-    ORDER_INVOICES_READY = "order-invoices-ready",
+    ORDER_INVOICED = "order-invoiced",
     ORDER_ISSUE_REPORTED = "order-issue-reported",
     ORDER_ISSUES_STATE_RECOMPUTE_REQUESTED = "order-issues-state-recompute-requested",
     PROCESS_ORDER_REFUND_INTENT = "process-order-refund-intent",

package/dist/gcp/pubsub/enums/PubSubTopics.enum.js

@@ -12,7 +12,7 @@ var PubSubTopics;
     PubSubTopics["ORDER_PAYMENT_SUCCEEDED"] = "order-payment-succeeded";
     PubSubTopics["ORDER_PAYMENT_FAILED"] = "order-payment-failed";
     PubSubTopics["ORDER_PAYMENT_CANCELED"] = "order-payment-canceled";
-    PubSubTopics["ORDER_INVOICES_READY"] = "order-invoices-ready";
+    PubSubTopics["ORDER_INVOICED"] = "order-invoiced";
     PubSubTopics["ORDER_ISSUE_REPORTED"] = "order-issue-reported";
     PubSubTopics["ORDER_ISSUES_STATE_RECOMPUTE_REQUESTED"] = "order-issues-state-recompute-requested";
     PubSubTopics["PROCESS_ORDER_REFUND_INTENT"] = "process-order-refund-intent";

package/dist/gcp/pubsub/maps/PubSubTopicMessageMap.map.d.ts

@@ -1,5 +1,5 @@
 import type { PubSubTopics } from "../enums";
-import type { PubSubAutoCancelConfirmedOrderMessage, PubSubAutoCompleteOrderAfterIssueReportingWindowMessage, PubSubBillingAlertsMessage, PubSubDefaultDlqMessage, PubSubEntityMemberProjectionResyncRequestedMessage, PubSubEntityVatNumberVerificationRequestedMessage, PubSubFirestoreUserMetricsMessage, PubSubNotificationEventMessage, PubSubOrderCompletedMessage, PubSubOrderInvoicesReadyMessage, PubSubOrderIssueReportedMessage, PubSubOrderIssueStateRecomputeRequestedMessage, PubSubOrderOperationalStateRecomputeRequestedMessage, PubSubOrderPaymentCanceledMessage, PubSubOrderPaymentFailedMessage, PubSubOrderPaymentSucceededMessage, PubSubProcessOrderRefundIntentMessage, PubSubOrderExternalRefundSucceededMessage, PubSubOrderExternalRefundFailedMessage, PubSubOrderStartedMessage, PubSubProcessWalletWithdrawalRequestMessage, PubSubServiceProviderBookedSlotReleaseRequestedMessage, PubSubServiceProviderEntityStateRecomputeRequestedMessage, PubSubServiceProviderPublicProfileResyncRequestedMessage, PubSubServicesCompletedMessage, PubSubStripeConnectedAccountBalanceAvailableUpdatedMessage, PubSubStripeConnectedAccountUpdatedMessage, PubSubUserOrderReminderMessage, PubSubWalletWithdrawalFailedMessage, PubSubWalletWithdrawalSucceededMessage } from "../types";
+import type { PubSubAutoCancelConfirmedOrderMessage, PubSubAutoCompleteOrderAfterIssueReportingWindowMessage, PubSubBillingAlertsMessage, PubSubDefaultDlqMessage, PubSubEntityMemberProjectionResyncRequestedMessage, PubSubEntityVatNumberVerificationRequestedMessage, PubSubFirestoreUserMetricsMessage, PubSubNotificationEventMessage, PubSubOrderCompletedMessage, PubSubOrderInvoicedMessage, PubSubOrderIssueReportedMessage, PubSubOrderIssueStateRecomputeRequestedMessage, PubSubOrderOperationalStateRecomputeRequestedMessage, PubSubOrderPaymentCanceledMessage, PubSubOrderPaymentFailedMessage, PubSubOrderPaymentSucceededMessage, PubSubProcessOrderRefundIntentMessage, PubSubOrderExternalRefundSucceededMessage, PubSubOrderExternalRefundFailedMessage, PubSubOrderStartedMessage, PubSubProcessWalletWithdrawalRequestMessage, PubSubServiceProviderBookedSlotReleaseRequestedMessage, PubSubServiceProviderEntityStateRecomputeRequestedMessage, PubSubServiceProviderPublicProfileResyncRequestedMessage, PubSubServicesCompletedMessage, PubSubStripeConnectedAccountBalanceAvailableUpdatedMessage, PubSubStripeConnectedAccountUpdatedMessage, PubSubUserOrderReminderMessage, PubSubWalletWithdrawalFailedMessage, PubSubWalletWithdrawalSucceededMessage } from "../types";
 type PubSubTopicMessageMapBase = {
     [PubSubTopics.BILLING_ALERTS]: PubSubBillingAlertsMessage;
     [PubSubTopics.STRIPE_CONNECTED_ACCOUNT_UPDATED]: PubSubStripeConnectedAccountUpdatedMessage;
@@ -13,7 +13,7 @@ type PubSubTopicMessageMapBase = {
     [PubSubTopics.USER_ORDER_REMINDER]: PubSubUserOrderReminderMessage;
     [PubSubTopics.ORDER_PAYMENT_FAILED]: PubSubOrderPaymentFailedMessage;
     [PubSubTopics.ORDER_PAYMENT_CANCELED]: PubSubOrderPaymentCanceledMessage;
-    [PubSubTopics.ORDER_INVOICES_READY]: PubSubOrderInvoicesReadyMessage;
+    [PubSubTopics.ORDER_INVOICED]: PubSubOrderInvoicedMessage;
     [PubSubTopics.ORDER_OPERATIONAL_STATE_RECOMPUTE_REQUESTED]: PubSubOrderOperationalStateRecomputeRequestedMessage;
     [PubSubTopics.SERVICES_COMPLETED]: PubSubServicesCompletedMessage;
     [PubSubTopics.AUTO_CANCEL_EXPIRED_CONFIRMED_ORDER]: PubSubAutoCancelConfirmedOrderMessage;

package/dist/gcp/pubsub/types/orders/PubSubOrderInvoicedMessage.type.d.ts

@@ -0,0 +1,3 @@
+export type PubSubOrderInvoicedMessage = {
+    orderDocumentId: string;
+};

package/dist/gcp/pubsub/types/orders/PubSubOrderInvoicedMessage.type.js

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

package/dist/gcp/pubsub/types/orders/index.d.ts

@@ -8,7 +8,7 @@ export * from "./PubSubServicesCompletedMessage.type";
 export * from "./PubSubUserOrderReminderMessage.type";
 export * from "./PubSubAutoCompleteOrderAfterIssueReportingWindowMessage.type";
 export * from "./PubSubOrderCompletedMessage.type";
-export * from "./PubSubOrderInvoicesReadyMessage.type";
+export * from "./PubSubOrderInvoicedMessage.type";
 export * from "./PubSubOrderIssueReportedMessage.type";
 export * from "./PubSubOrderIssueStateRecomputeRequestedMessage.type";
 export * from "./PubSubProcessOrderRefundIntentMessage.type";

package/dist/gcp/pubsub/types/orders/index.js

@@ -24,7 +24,7 @@ __exportStar(require("./PubSubServicesCompletedMessage.type"), exports);
 __exportStar(require("./PubSubUserOrderReminderMessage.type"), exports);
 __exportStar(require("./PubSubAutoCompleteOrderAfterIssueReportingWindowMessage.type"), exports);
 __exportStar(require("./PubSubOrderCompletedMessage.type"), exports);
-__exportStar(require("./PubSubOrderInvoicesReadyMessage.type"), exports);
+__exportStar(require("./PubSubOrderInvoicedMessage.type"), exports);
 __exportStar(require("./PubSubOrderIssueReportedMessage.type"), exports);
 __exportStar(require("./PubSubOrderIssueStateRecomputeRequestedMessage.type"), exports);
 __exportStar(require("./PubSubProcessOrderRefundIntentMessage.type"), exports);

package/dist/gcp/pubsub/utils/stubs/index.d.ts

@@ -8,7 +8,7 @@ export * from "./pubSubOrderStartedMessageStub";
 export * from "./pubSubNotificationEventMessageStub";
 export * from "./pubSubServicesCompletedMessageStub";
 export * from "./pubSubUserOrderReminderMessageStub";
-export * from "./pubSubOrderInvoicesReadyMessageStub";
+export * from "./pubSubOrderInvoicedMessageStub";
 export * from "./pubSubStripeConnectedAccountBalanceAvailableUpdatedMessageStub";
 export * from "./wallets";
 export * from "./pubSubOrderIssueReportedMessageStub";

package/dist/gcp/pubsub/utils/stubs/index.js

@@ -24,7 +24,7 @@ __exportStar(require("./pubSubOrderStartedMessageStub"), exports);
 __exportStar(require("./pubSubNotificationEventMessageStub"), exports);
 __exportStar(require("./pubSubServicesCompletedMessageStub"), exports);
 __exportStar(require("./pubSubUserOrderReminderMessageStub"), exports);
-__exportStar(require("./pubSubOrderInvoicesReadyMessageStub"), exports);
+__exportStar(require("./pubSubOrderInvoicedMessageStub"), exports);
 __exportStar(require("./pubSubStripeConnectedAccountBalanceAvailableUpdatedMessageStub"), exports);
 __exportStar(require("./wallets"), exports);
 __exportStar(require("./pubSubOrderIssueReportedMessageStub"), exports);

package/dist/gcp/pubsub/utils/stubs/pubSubOrderInvoicedMessageStub.d.ts

@@ -0,0 +1,2 @@
+import type { PubSubOrderInvoicedMessage } from "../../types";
+export declare function pubSubOrderInvoicedMessageStub(overwrite?: Partial<PubSubOrderInvoicedMessage>): PubSubOrderInvoicedMessage;

package/dist/gcp/pubsub/utils/stubs/pubSubOrderInvoicedMessageStub.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pubSubOrderInvoicedMessageStub = pubSubOrderInvoicedMessageStub;
+function pubSubOrderInvoicedMessageStub(overwrite = {}) {
+    return {
+        orderDocumentId: "order-document-id",
+        ...overwrite,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doctocar/tooling",
-  "version": "0.3.1-34",
+  "version": "0.3.1-35",
   "description": "A set of tools for DoctoCar projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",