@lookiero/checkout 0.8.4-beta.1 → 0.8.4-beta.10

package/dist/domain/checkout/command/markCheckoutAsPaid.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@lookiero/messaging";
+declare const MARK_CHECKOUT_AS_PAID = "mark_checkout_as_paid";
+interface MarkCheckoutAsPaidPayload {
+    readonly aggregateId: string;
+}
+interface MarkCheckoutAsPaid extends Command<typeof MARK_CHECKOUT_AS_PAID>, MarkCheckoutAsPaidPayload {
+}
+interface MarkCheckoutAsPaidFunction {
+    (payload: MarkCheckoutAsPaidPayload): MarkCheckoutAsPaid;
+}
+declare const markCheckoutAsPaid: MarkCheckoutAsPaidFunction;
+export type { MarkCheckoutAsPaid };
+export { MARK_CHECKOUT_AS_PAID, markCheckoutAsPaid };

package/dist/domain/checkout/command/markCheckoutAsPaid.js

@@ -0,0 +1,4 @@
+import { command } from "@lookiero/messaging";
+const MARK_CHECKOUT_AS_PAID = "mark_checkout_as_paid";
+const markCheckoutAsPaid = ({ aggregateId }) => command({ aggregateId, name: MARK_CHECKOUT_AS_PAID });
+export { MARK_CHECKOUT_AS_PAID, markCheckoutAsPaid };

package/dist/domain/checkout/model/checkout.js

@@ -11,6 +11,7 @@ var CheckoutStatus;
 })(CheckoutStatus || (CheckoutStatus = {}));
 const startCheckoutHandler = () => async ({ aggregateRoot, command }) => {
     const { aggregateId } = command;
+    invariant(aggregateRoot.status !== CheckoutStatus.STARTED, "Checkout is already started");
     invariant(aggregateRoot.status !== CheckoutStatus.SUBMITTED, "Checkout is already submitted");
     invariant(aggregateRoot.status !== CheckoutStatus.COMPLETED, "Checkout is already completed");
     return {

package/dist/domain/checkout/model/checkoutPaid.d.ts

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@lookiero/messaging";
+declare const CHECKOUT_PAID = "checkout_paid";
+interface CheckoutPaidPayload {
+    readonly aggregateId: string;
+}
+interface CheckoutPaid extends DomainEvent<typeof CHECKOUT_PAID>, CheckoutPaidPayload {
+}
+interface CheckoutPaidFunction {
+    (payload: CheckoutPaidPayload): CheckoutPaid;
+}
+declare const checkoutPaid: CheckoutPaidFunction;
+export type { CheckoutPaid };
+export { CHECKOUT_PAID, checkoutPaid };

package/dist/domain/checkout/model/checkoutPaid.js

@@ -0,0 +1,4 @@
+import { domainEvent } from "@lookiero/messaging";
+const CHECKOUT_PAID = "checkout_paid";
+const checkoutPaid = ({ aggregateId }) => domainEvent({ aggregateId, name: CHECKOUT_PAID });
+export { CHECKOUT_PAID, checkoutPaid };

package/dist/infrastructure/delivery/http/fetchHttpClient.js

@@ -1,20 +1,37 @@
-const fetchHttpPost = ({ apiUrl, getAuthToken }) => async ({ endpoint, body, signal }) => fetch(`${apiUrl}${endpoint}`, {
-    method: "POST",
-    headers: {
-        ["Content-Type"]: "application/json",
-        authorization: `Bearer ${await getAuthToken()}`,
-    },
-    body: JSON.stringify(body),
-    signal,
-});
-const fetchHttpGet = ({ apiUrl, getAuthToken }) => async ({ endpoint, signal }) => fetch(`${apiUrl}${endpoint}`, {
-    method: "GET",
-    credentials: "include",
-    headers: {
-        Authorization: `Bearer ${await getAuthToken()}`,
-        ["Content-Type"]: "application/json",
-    },
-    referrer: "",
-    signal,
-});
+const fetchHttpPost = ({ apiUrl, getAuthToken }) => async ({ endpoint, body, signal, result }) => {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+        method: "POST",
+        headers: {
+            ["Content-Type"]: "application/json",
+            authorization: `Bearer ${await getAuthToken()}`,
+        },
+        body: JSON.stringify(body),
+        signal,
+    });
+    return await processResponse({ response, result });
+};
+const fetchHttpGet = ({ apiUrl, getAuthToken }) => async ({ endpoint, signal, result }) => {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+        method: "GET",
+        credentials: "include",
+        headers: {
+            Authorization: `Bearer ${await getAuthToken()}`,
+            ["Content-Type"]: "application/json",
+        },
+        referrer: "",
+        signal,
+    });
+    return await processResponse({ response, result });
+};
+const processResponse = async ({ response, result }) => {
+    if (response.ok) {
+        const responseText = await response.text();
+        const responseResult = responseText ? JSON.parse(responseText) : responseText;
+        return result?.success(responseResult) ?? responseResult;
+    }
+    if (result?.error !== undefined) {
+        return result.error;
+    }
+    throw new Error(response.statusText);
+};
 export { fetchHttpGet, fetchHttpPost };

package/dist/infrastructure/delivery/http/httpClient.d.ts

@@ -1,16 +1,22 @@
+interface HttpFunctionResult {
+    readonly error: any;
+    readonly success: (response: any) => any;
+}
 interface HttpGetFunctionArgs {
     readonly endpoint: string;
     readonly signal?: AbortSignal;
+    readonly result?: HttpFunctionResult;
 }
 interface HttpGetFunction {
-    (args: HttpGetFunctionArgs): Promise<Response>;
+    (args: HttpGetFunctionArgs): Promise<any>;
 }
 interface HttpPostFunctionArgs {
     readonly endpoint: string;
     readonly body: Record<string, unknown>;
     readonly signal?: AbortSignal;
+    readonly result?: HttpFunctionResult;
 }
 interface HttpPostFunction {
-    (args: HttpPostFunctionArgs): Promise<Response>;
+    (args: HttpPostFunctionArgs): Promise<any>;
 }
-export type { HttpGetFunction, HttpPostFunction };
+export type { HttpGetFunction, HttpPostFunction, HttpFunctionResult };

package/dist/infrastructure/domain/checkout/model/httpCheckoutsMarkAsPaid.d.ts

@@ -0,0 +1,5 @@
+import { HttpCheckoutsSaveFunction } from "./httpCheckouts";
+interface HttpCheckoutsMarkAsPaidFunction extends HttpCheckoutsSaveFunction {
+}
+declare const httpCheckoutsMarkAsPaid: HttpCheckoutsMarkAsPaidFunction;
+export { httpCheckoutsMarkAsPaid };

package/dist/infrastructure/domain/checkout/model/httpCheckoutsMarkAsPaid.js

@@ -0,0 +1,13 @@
+import { CHECKOUT_PAID } from "../../../../domain/checkout/model/checkoutPaid";
+const isCheckoutPaid = (event) => event.name === CHECKOUT_PAID;
+const httpCheckoutsMarkAsPaid = ({ httpPost }) => async ({ aggregateId, domainEvents }) => {
+    const checkoutPaid = domainEvents.find(isCheckoutPaid);
+    if (!checkoutPaid) {
+        return;
+    }
+    await httpPost({
+        endpoint: "/mark-checkout-as-paid",
+        body: { checkoutId: aggregateId },
+    });
+};
+export { httpCheckoutsMarkAsPaid };

package/dist/infrastructure/domain/checkout/react/useMarkCheckoutAsPaid.d.ts

@@ -0,0 +1,13 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface MarkAsPaidFunction {
+    (): Promise<void>;
+}
+type UseMarkCheckoutAsPaid = [markAsPaid: MarkAsPaidFunction, status: CommandStatus];
+interface UseMarkCheckoutAsPaidFunctionArgs {
+    readonly checkoutId?: string;
+}
+interface UseMarkCheckoutAsPaidFunction {
+    (args: UseMarkCheckoutAsPaidFunctionArgs): UseMarkCheckoutAsPaid;
+}
+declare const useMarkCheckoutAsPaid: UseMarkCheckoutAsPaidFunction;
+export { useMarkCheckoutAsPaid };

package/dist/infrastructure/domain/checkout/react/useMarkCheckoutAsPaid.js

@@ -0,0 +1,16 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import invariant from "tiny-invariant";
+import { markCheckoutAsPaid } from "../../../../domain/checkout/command/markCheckoutAsPaid";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const useMarkCheckoutAsPaid = ({ checkoutId }) => {
+    const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+    const markAsPaid = useCallback(() => {
+        invariant(checkoutId, "CheckoutId must be defined in order to mark the checkout as paid");
+        return commandBus(markCheckoutAsPaid({
+            aggregateId: checkoutId,
+        }));
+    }, [checkoutId, commandBus]);
+    return [markAsPaid, status];
+};
+export { useMarkCheckoutAsPaid };

package/dist/infrastructure/domain/checkout/react/useStartCheckout.d.ts

@@ -1,9 +1,11 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface StartCheckoutFunction {
-    (): Promise<void>;
+    (): Promise<void> | undefined;
 }
 interface UseStartCheckoutArgs {
     readonly checkoutId?: string;
+    readonly logger: Logger;
 }
 type UseStartCheckoutResult = [start: StartCheckoutFunction, status: CommandStatus];
 interface UseStartCheckout {

package/dist/infrastructure/domain/checkout/react/useStartCheckout.js

@@ -3,12 +3,19 @@ import { useCallback } from "react";
 import invariant from "tiny-invariant";
 import { startCheckout } from "../../../../domain/checkout/command/startCheckout";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useStartCheckout = ({ checkoutId }) => {
+const useStartCheckout = ({ checkoutId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const start = useCallback(() => {
+    const start = useCallback(async () => {
         invariant(checkoutId, "CheckoutId must be defined in order to start checkout");
-        return commandBus(startCheckout({ aggregateId: checkoutId }));
-    }, [checkoutId, commandBus]);
+        try {
+            return await commandBus(startCheckout({ aggregateId: checkoutId }));
+        }
+        catch (error) {
+            if (!error?.message?.includes("Checkout is already started")) {
+                logger.captureException(error);
+            }
+        }
+    }, [checkoutId, commandBus, logger]);
     return [start, status];
 };
 export { useStartCheckout };

package/dist/infrastructure/domain/checkout/react/useSubmitCheckout.d.ts

@@ -1,10 +1,12 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface SubmitFunction {
-    (): Promise<void>;
+    (): Promise<void> | undefined;
 }
 type UseSubmitCheckout = [submit: SubmitFunction, status: CommandStatus];
 interface UseSubmitCheckoutFunctionArgs {
     readonly checkoutId?: string;
+    readonly logger: Logger;
 }
 interface UseSubmitCheckoutFunction {
     (args: UseSubmitCheckoutFunctionArgs): UseSubmitCheckout;

package/dist/infrastructure/domain/checkout/react/useSubmitCheckout.js

@@ -2,15 +2,28 @@ import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import invariant from "tiny-invariant";
 import { submitCheckout } from "../../../../domain/checkout/command/submitCheckout";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useSubmitCheckout = ({ checkoutId }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useSubmitCheckout = ({ checkoutId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const submit = useCallback(() => {
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const submit = useCallback(async () => {
         invariant(checkoutId, "CheckoutId must be defined in order to submit checkout");
-        return commandBus(submitCheckout({
-            aggregateId: checkoutId,
-        }));
-    }, [checkoutId, commandBus]);
+        try {
+            return await commandBus(submitCheckout({
+                aggregateId: checkoutId,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutId, commandBus, createNotification, logger]);
     return [submit, status];
 };
 export { useSubmitCheckout };

package/dist/infrastructure/domain/checkoutBooking/react/useBlockCheckoutBooking.d.ts

@@ -1,10 +1,12 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface BlockCheckoutBookingFunction {
     (): Promise<void>;
 }
 type UseBlockCheckoutBooking = [blockCheckoutBooking: BlockCheckoutBookingFunction, status: CommandStatus];
 interface UseBlockCheckoutBookingFunctionArgs {
     readonly checkoutBookingId: string;
+    readonly logger: Logger;
 }
 interface UseBlockCheckoutBookingFunction {
     (args: UseBlockCheckoutBookingFunctionArgs): UseBlockCheckoutBooking;

package/dist/infrastructure/domain/checkoutBooking/react/useBlockCheckoutBooking.js

@@ -1,12 +1,27 @@
 import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import { blockCheckoutBooking as blockCheckoutBookingCommand } from "../../../../domain/checkoutBooking/command/blockCheckoutBooking";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useBlockCheckoutBooking = ({ checkoutBookingId }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useBlockCheckoutBooking = ({ checkoutBookingId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const blockCheckoutBooking = useCallback(() => commandBus(blockCheckoutBookingCommand({
-        aggregateId: checkoutBookingId,
-    })), [checkoutBookingId, commandBus]);
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const blockCheckoutBooking = useCallback(async () => {
+        try {
+            await commandBus(blockCheckoutBookingCommand({
+                aggregateId: checkoutBookingId,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutBookingId, commandBus, createNotification, logger]);
     return [blockCheckoutBooking, status];
 };
 export { useBlockCheckoutBooking };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckouBookingForCheckoutItem.d.ts

@@ -0,0 +1,13 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface BookFunction {
+    (): Promise<void>;
+}
+type UseBookCheckouBookingForCheckoutItem = [book: BookFunction, status: CommandStatus];
+interface UseBookCheckouBookingForCheckoutItemFunctionArgs {
+    readonly checkoutItemId: string;
+}
+interface UseBookCheckouBookingForCheckoutItemFunction {
+    (args: UseBookCheckouBookingForCheckoutItemFunctionArgs): UseBookCheckouBookingForCheckoutItem;
+}
+declare const useBookCheckouBookingForCheckoutItem: UseBookCheckouBookingForCheckoutItemFunction;
+export { useBookCheckouBookingForCheckoutItem };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckouBookingForCheckoutItem.js

@@ -0,0 +1,14 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { bookCheckoutBookingForCheckoutItem } from "../../../../domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const useBookCheckouBookingForCheckoutItem = ({ checkoutItemId }) => {
+    const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+    const book = useCallback(() => commandBus(bookCheckoutBookingForCheckoutItem({
+        aggregateId: uuid(),
+        checkoutItemId,
+    })), [checkoutItemId, commandBus]);
+    return [book, status];
+};
+export { useBookCheckouBookingForCheckoutItem };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckoutBookingForCheckoutItem.d.ts

@@ -1,4 +1,5 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface BookFunction {
     (): Promise<void>;
 }
@@ -6,6 +7,7 @@ type UseBookCheckoutBookingForCheckoutItem = [book: BookFunction, status: Comman
 interface UseBookCheckoutBookingForCheckoutItemFunctionArgs {
     readonly checkoutItemId: string;
     readonly checkoutBookingId: string | undefined;
+    readonly logger: Logger;
 }
 interface UseBookCheckoutBookingForCheckoutItemFunction {
     (args: UseBookCheckoutBookingForCheckoutItemFunctionArgs): UseBookCheckoutBookingForCheckoutItem;

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckoutBookingForCheckoutItem.js

@@ -2,13 +2,28 @@ import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import { v4 as uuid } from "uuid";
 import { bookCheckoutBookingForCheckoutItem } from "../../../../domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useBookCheckoutBookingForCheckoutItem = ({ checkoutItemId, checkoutBookingId, }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useBookCheckoutBookingForCheckoutItem = ({ checkoutItemId, checkoutBookingId, logger, }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const book = useCallback(() => commandBus(bookCheckoutBookingForCheckoutItem({
-        aggregateId: checkoutBookingId || uuid(),
-        checkoutItemId,
-    })), [checkoutBookingId, checkoutItemId, commandBus]);
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const book = useCallback(async () => {
+        try {
+            await commandBus(bookCheckoutBookingForCheckoutItem({
+                aggregateId: checkoutBookingId || uuid(),
+                checkoutItemId,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutBookingId, checkoutItemId, commandBus, createNotification, logger]);
     return [book, status];
 };
 export { useBookCheckoutBookingForCheckoutItem };

package/dist/infrastructure/domain/checkoutFeedback/react/useGiveCheckoutFeedback.d.ts

@@ -1,5 +1,6 @@
 import { CommandStatus } from "@lookiero/messaging-react";
 import { Feedbacks } from "../../../../domain/checkoutFeedback/model/feedbacks";
+import { Logger } from "../../../../shared/logging/Logger";
 interface GiveCheckoutFeedbackFunctionArgs {
     readonly feedbacks: Feedbacks;
 }
@@ -9,6 +10,7 @@ interface GiveCheckoutFeedbackFunction {
 type UseGiveCheckoutFeedback = [giveCheckoutFeedback: GiveCheckoutFeedbackFunction, status: CommandStatus];
 interface UseGiveCheckoutFeedbackFunctionArgs {
     readonly checkoutId: string;
+    readonly logger: Logger;
 }
 interface UseGiveCheckoutFeedbackFunction {
     (args: UseGiveCheckoutFeedbackFunctionArgs): UseGiveCheckoutFeedback;

package/dist/infrastructure/domain/checkoutFeedback/react/useGiveCheckoutFeedback.js

@@ -1,13 +1,28 @@
 import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import { giveCheckoutFeedback as giveCheckoutFeedbackCommand } from "../../../../domain/checkoutFeedback/command/giveCheckoutFeedback";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useGiveCheckoutFeedback = ({ checkoutId }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useGiveCheckoutFeedback = ({ checkoutId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const giveCheckoutFeedback = useCallback(({ feedbacks }) => commandBus(giveCheckoutFeedbackCommand({
-        checkoutId,
-        feedbacks,
-    })), [checkoutId, commandBus]);
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const giveCheckoutFeedback = useCallback(async ({ feedbacks }) => {
+        try {
+            await commandBus(giveCheckoutFeedbackCommand({
+                checkoutId,
+                feedbacks,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutId, commandBus, createNotification, logger]);
     return [giveCheckoutFeedback, status];
 };
 export { useGiveCheckoutFeedback };

package/dist/infrastructure/domain/checkoutItem/react/useKeepCheckoutItem.d.ts

@@ -1,9 +1,11 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface KeepCheckoutItemFunction {
     (): Promise<void>;
 }
 interface UseKeepCheckoutItemFunctionArgs {
     readonly checkoutItemId: string;
+    readonly logger: Logger;
 }
 type UseKeepCheckoutItemResult = [keep: KeepCheckoutItemFunction, status: CommandStatus];
 interface UseKeepCheckoutItemFunction {

package/dist/infrastructure/domain/checkoutItem/react/useKeepCheckoutItem.js

@@ -1,12 +1,27 @@
 import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import { keepCheckoutItem } from "../../../../domain/checkoutItem/command/keepCheckoutItem";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useKeepCheckoutItem = ({ checkoutItemId }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useKeepCheckoutItem = ({ checkoutItemId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const keep = useCallback(() => commandBus(keepCheckoutItem({
-        aggregateId: checkoutItemId,
-    })), [checkoutItemId, commandBus]);
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const keep = useCallback(async () => {
+        try {
+            await commandBus(keepCheckoutItem({
+                aggregateId: checkoutItemId,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutItemId, commandBus, createNotification, logger]);
     return [keep, status];
 };
 export { useKeepCheckoutItem };

package/dist/infrastructure/domain/checkoutItem/react/useReplaceCheckoutItem.d.ts

@@ -1,4 +1,5 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface ReplaceCheckoutItemFunctionArgs {
     readonly replacedForId: string;
 }
@@ -7,6 +8,7 @@ interface ReplaceCheckoutItemFunction {
 }
 interface UseReplaceCheckoutItemFunctionArgs {
     readonly checkoutItemId: string;
+    readonly logger: Logger;
 }
 type UseReplaceCheckoutItemResult = [replace: ReplaceCheckoutItemFunction, status: CommandStatus];
 interface UseReplaceCheckoutItemFunction {

package/dist/infrastructure/domain/checkoutItem/react/useReplaceCheckoutItem.js

@@ -1,13 +1,28 @@
 import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import { replaceCheckoutItem } from "../../../../domain/checkoutItem/command/replaceCheckoutItem";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useReplaceCheckoutItem = ({ checkoutItemId }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useReplaceCheckoutItem = ({ checkoutItemId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const replace = useCallback(({ replacedForId }) => commandBus(replaceCheckoutItem({
-        aggregateId: checkoutItemId,
-        replacedForId,
-    })), [checkoutItemId, commandBus]);
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const replace = useCallback(async ({ replacedForId }) => {
+        try {
+            await commandBus(replaceCheckoutItem({
+                aggregateId: checkoutItemId,
+                replacedForId,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutItemId, commandBus, createNotification, logger]);
     return [replace, status];
 };
 export { useReplaceCheckoutItem };

package/dist/infrastructure/domain/checkoutItem/react/useReturnCheckoutItem.d.ts

@@ -1,5 +1,6 @@
 import { CommandStatus } from "@lookiero/messaging-react";
 import { Feedbacks } from "../../../../domain/checkoutItem/model/feedbacks";
+import { Logger } from "../../../../shared/logging/Logger";
 interface ReturnCheckoutItemFunctionArgs {
     readonly feedbacks: Feedbacks;
 }
@@ -8,6 +9,7 @@ interface ReturnCheckoutItemFunction {
 }
 interface UseReturnCheckoutItemFunctionArgs {
     readonly checkoutItemId: string;
+    readonly logger: Logger;
 }
 type UseReturnCheckoutItemResult = [returnCheckoutItem: ReturnCheckoutItemFunction, status: CommandStatus];
 interface UseReturnCheckoutItemFunction {

package/dist/infrastructure/domain/checkoutItem/react/useReturnCheckoutItem.js

@@ -1,13 +1,28 @@
 import { useCommand } from "@lookiero/messaging-react";
 import { useCallback } from "react";
 import { returnCheckoutItem as returnCheckoutItemCommand } from "../../../../domain/checkoutItem/command/returnCheckoutItem";
+import { useCreateNotification } from "../../../../shared/notifications";
+import { NotificationLevel } from "../../../../shared/notifications/domain/notification/model/notification";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useReturnCheckoutItem = ({ checkoutItemId }) => {
+import { I18nMessages } from "../../../ui/i18n/i18n";
+const useReturnCheckoutItem = ({ checkoutItemId, logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const returnCheckoutItem = useCallback(({ feedbacks }) => commandBus(returnCheckoutItemCommand({
-        aggregateId: checkoutItemId,
-        feedbacks,
-    })), [checkoutItemId, commandBus]);
+    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+    const returnCheckoutItem = useCallback(async ({ feedbacks }) => {
+        try {
+            await commandBus(returnCheckoutItemCommand({
+                aggregateId: checkoutItemId,
+                feedbacks,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+            createNotification({
+                level: NotificationLevel.ERROR,
+                bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+            });
+        }
+    }, [checkoutItemId, commandBus, createNotification, logger]);
     return [returnCheckoutItem, status];
 };
 export { useReturnCheckoutItem };

package/dist/infrastructure/domain/uiSetting/react/useUpdateUiSetting.d.ts

@@ -1,4 +1,5 @@
 import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../shared/logging/Logger";
 interface UpdateFunctionArgs {
     readonly key: string;
     readonly value: unknown;
@@ -7,8 +8,11 @@ interface UpdateFunction {
     (args: UpdateFunctionArgs): Promise<void>;
 }
 type UseUpdateUiSetting = [update: UpdateFunction, status: CommandStatus];
+interface UseUpdateUiSettingArgs {
+    readonly logger: Logger;
+}
 interface UseUpdateUiSettingFunction {
-    (): UseUpdateUiSetting;
+    (args: UseUpdateUiSettingArgs): UseUpdateUiSetting;
 }
 declare const useUpdateUiSetting: UseUpdateUiSettingFunction;
 export { useUpdateUiSetting };