@lookiero/checkout 0.8.4-beta.2 → 0.8.4

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/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/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,28 @@
 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,
+            });
+            throw error;
+        }
+    }, [checkoutBookingId, commandBus, createNotification, logger]);
     return [blockCheckoutBooking, status];
 };
 export { useBlockCheckoutBooking };

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

package/dist/infrastructure/domain/uiSetting/react/useUpdateUiSetting.js

@@ -3,13 +3,20 @@ import { useCallback } from "react";
 import { v4 as uuid } from "uuid";
 import { updateUiSetting } from "../../../../domain/uiSetting/command/updateUiSetting";
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
-const useUpdateUiSetting = () => {
+const useUpdateUiSetting = ({ logger }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const update = useCallback(({ key, value }) => commandBus(updateUiSetting({
-        aggregateId: uuid(),
-        key,
-        value,
-    })), [commandBus]);
+    const update = useCallback(async ({ key, value }) => {
+        try {
+            await commandBus(updateUiSetting({
+                aggregateId: uuid(),
+                key,
+                value,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+        }
+    }, [commandBus, logger]);
     return [update, status];
 };
 export { useUpdateUiSetting };

package/dist/infrastructure/projection/bookedProductsVariants/httpBookedProductsVariantsForCheckoutItemView.js

@@ -1,9 +1,10 @@
-const httpBookedProductsVariantsForCheckoutItemView = ({ httpPost }) => async ({ checkoutItemId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-booked-product-variants-for-checkout-item",
-        body: { checkoutItemId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpBookedProductsVariantsForCheckoutItemView = ({ httpPost }) => async ({ checkoutItemId, signal }) => await httpPost({
+    endpoint: "/view-booked-product-variants-for-checkout-item",
+    body: { checkoutItemId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpBookedProductsVariantsForCheckoutItemView };

package/dist/infrastructure/projection/checkout/httpCheckoutByIdView.js

@@ -1,10 +1,11 @@
 import { toCheckoutProjection } from "./checkout";
-const httpCheckoutByIdView = ({ httpPost }) => async ({ checkoutId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-checkout-by-id",
-        body: { checkoutId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : toCheckoutProjection((await response.json()).result);
-};
+const httpCheckoutByIdView = ({ httpPost }) => async ({ checkoutId, signal }) => await httpPost({
+    endpoint: "/view-checkout-by-id",
+    body: { checkoutId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => toCheckoutProjection(response.result),
+    },
+});
 export { httpCheckoutByIdView };

package/dist/infrastructure/projection/checkout/httpFirstAvailableCheckoutByCustomerIdView.js

@@ -1,10 +1,11 @@
 import { toCheckoutProjection } from "./checkout";
-const httpFirstAvailableCheckoutByCustomerIdView = ({ httpPost }) => async ({ customerId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-first-available-checkout-by-customer-id",
-        body: { customerId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : toCheckoutProjection((await response.json()).result);
-};
+const httpFirstAvailableCheckoutByCustomerIdView = ({ httpPost }) => async ({ customerId, signal }) => await httpPost({
+    endpoint: "/view-first-available-checkout-by-customer-id",
+    body: { customerId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => toCheckoutProjection(response.result),
+    },
+});
 export { httpFirstAvailableCheckoutByCustomerIdView };

package/dist/infrastructure/projection/checkout/httpFiveItemsDiscountByCustomerIdView.js

@@ -1,8 +1,9 @@
-const httpFiveItemsDiscountByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => {
-    const response = await httpGet({
-        endpoint: `/view-five-items-discount-by-customer-id/${customerId}`,
-        signal,
-    });
-    return !response.ok ? 0 : await response.json();
-};
+const httpFiveItemsDiscountByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => await httpGet({
+    endpoint: `/view-five-items-discount-by-customer-id/${customerId}`,
+    signal,
+    result: {
+        error: 0,
+        success: (response) => response,
+    },
+});
 export { httpFiveItemsDiscountByCustomerIdView };

package/dist/infrastructure/projection/checkout/httpIsCheckoutEnabledByCustomerIdView.js

@@ -1,8 +1,9 @@
-const httpIsCheckoutEnabledByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => {
-    const response = await httpGet({
-        endpoint: `/is-new-checkout-enabled/${customerId}`,
-        signal,
-    });
-    return !response.ok ? false : await response.json();
-};
+const httpIsCheckoutEnabledByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => await httpGet({
+    endpoint: `/is-new-checkout-enabled/${customerId}`,
+    signal,
+    result: {
+        error: false,
+        success: (response) => response,
+    },
+});
 export { httpIsCheckoutEnabledByCustomerIdView };