@lookiero/checkout 0.1.2 → 0.2.0

package/src/infrastructure/domain/uiSetting/model/storageUiSettings.ts

@@ -1,52 +0,0 @@
-import { UiSetting } from "../../../../domain/uiSetting/model/uiSetting";
-import { UiSettingGetFunction, UiSettingSaveFunction } from "../../../../domain/uiSetting/model/uiSettings";
-import { ReadFunction, WriteFunction } from "../../../persistence/storage";
-import { UiSettingDto } from "../../../persistence/uiSettingData";
-
-const toDomain = (uiSettingDto: UiSettingDto): UiSetting => ({
-  aggregateId: uiSettingDto.id,
-  key: uiSettingDto.key,
-  value: uiSettingDto.value,
-  domainEvents: [],
-});
-
-const fromDomain = (uiSetting: UiSetting): UiSettingDto => ({
-  id: uiSetting.aggregateId,
-  key: uiSetting.key,
-  value: uiSetting.value,
-});
-
-interface StorageUiSettingsGetFunctionArgs {
-  readonly read: ReadFunction<UiSettingDto>;
-}
-
-interface StorageUiSettingsGetFunction {
-  (args: StorageUiSettingsGetFunctionArgs): UiSettingGetFunction;
-}
-
-const getUiSetting: StorageUiSettingsGetFunction =
-  ({ read }) =>
-  async (uiSettingKey) => {
-    const uiSettingDto = await read(uiSettingKey);
-
-    if (!uiSettingDto) {
-      throw new Error(`UiSetting not found: ${uiSettingKey}`);
-    }
-
-    return toDomain(uiSettingDto);
-  };
-
-interface StorageUiSettingsSaveFunctionArgs {
-  readonly write: WriteFunction<UiSettingDto>;
-}
-
-interface StorageUiSettingsSaveFunction {
-  (args: StorageUiSettingsSaveFunctionArgs): UiSettingSaveFunction;
-}
-
-const saveUiSetting: StorageUiSettingsSaveFunction =
-  ({ write }) =>
-  async (aggregateRoot) =>
-    await write(aggregateRoot.key, fromDomain(aggregateRoot));
-
-export { getUiSetting, saveUiSetting };

package/src/infrastructure/persistence/asyncStorageStorage.ts

@@ -1,13 +0,0 @@
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import { ReadFunction, WriteFunction } from "./storage";
-import { UiSettingDto } from "./uiSettingData";
-
-const read: ReadFunction<UiSettingDto> = async (key) => {
-  const value = await AsyncStorage.getItem(key);
-
-  return value ? JSON.parse(value) : undefined;
-};
-
-const write: WriteFunction<UiSettingDto> = async (key, value) => AsyncStorage.setItem(key, JSON.stringify(value));
-
-export { read, write };

package/src/infrastructure/persistence/storage.ts

@@ -1,9 +0,0 @@
-interface ReadFunction<T> {
-  (key: string): Promise<T | undefined>;
-}
-
-interface WriteFunction<T> {
-  (key: string, value: T): Promise<void>;
-}
-
-export { ReadFunction, WriteFunction };

package/src/infrastructure/persistence/uiSettingData.ts

@@ -1,7 +0,0 @@
-interface UiSettingDto {
-  readonly id: string;
-  readonly key: string;
-  readonly value: unknown;
-}
-
-export { UiSettingDto };

package/src/infrastructure/projection/httpBookedSizeReplaceableProductVariantsForCheckoutItemView.test.ts

@@ -1,65 +0,0 @@
-import {
-  BookedSizeReplaceableProductVariantsDto,
-  httpBookedSizeReplaceableProductVariantsForCheckoutItemView,
-  toBookedSizeReplaceableProductVariants,
-} from "./httpBookedSizeReplaceableProductVariantsForCheckoutItemView";
-
-const checkoutItemId = "6f720954-8039-4bed-9596-34fc5a02131b";
-const bookedSizeReplaceableProductVariantsResponse: { result: BookedSizeReplaceableProductVariantsDto } = {
-  result: {
-    booking: "b00e2c2d-7d9c-4808-88a4-e1c845ae6889",
-    product_variants: [
-      {
-        id: "383fab95-56eb-4639-bb18-530ab792b4d3",
-        size: {
-          id: "4f8a26b8-8d2d-4012-b49a-7d2820095598",
-          europe: { size: "36", format: "36" },
-          lookiero: { size: "S", format: "S" },
-          uk: { size: "8", format: "8" },
-          it: { size: "M", format: "M" },
-        },
-      },
-    ],
-  },
-};
-const bookedSizeReplaceableProductVariantsResponseOk: Response = {
-  ok: true,
-  status: 200,
-  json: () => Promise.resolve(bookedSizeReplaceableProductVariantsResponse),
-} as Response;
-const bookedSizeReplaceableProductVariantsResponseNotFound: Response = {
-  ok: false,
-  status: 404,
-} as Response;
-const bookedSizeReplaceableProductVariantsResponseError: Response = {
-  ok: false,
-} as Response;
-
-const httpPostMock = jest.fn();
-const view = httpBookedSizeReplaceableProductVariantsForCheckoutItemView({ httpPost: httpPostMock });
-
-describe("httpBookedSizeReplaceableProductVariantsForCheckoutItemView", () => {
-  it("returns a BookedSizeReplaceableProductVariants projection for a 200 response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(bookedSizeReplaceableProductVariantsResponseOk));
-
-    const returnedBookedSizeReplaceableProductVariants = await view({ checkoutItemId });
-
-    expect(returnedBookedSizeReplaceableProductVariants).toStrictEqual(
-      toBookedSizeReplaceableProductVariants(bookedSizeReplaceableProductVariantsResponse.result),
-    );
-  });
-
-  it("returns undefined for a 404 response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(bookedSizeReplaceableProductVariantsResponseNotFound));
-
-    const returnedBookedSizeReplaceableProductVariants = await view({ checkoutItemId });
-
-    expect(returnedBookedSizeReplaceableProductVariants).toBeUndefined();
-  });
-
-  it("throws for an unsuccessfull response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(bookedSizeReplaceableProductVariantsResponseError));
-
-    await expect(view({ checkoutItemId })).rejects.toThrow();
-  });
-});

package/src/infrastructure/projection/httpBookedSizeReplaceableProductVariantsForCheckoutItemView.ts

@@ -1,102 +0,0 @@
-import {
-  BookedSizeReplaceableProductVariantsProjection,
-  BookedSizeReplaceableProductVariantsForCheckoutItemView,
-  ProductVariant,
-  Size,
-} from "../../projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem";
-import { HttpPostFunction } from "../delivery/http/httpClient";
-
-interface SizeFormatDto {
-  readonly size: string;
-  readonly format: string;
-  readonly length?: string;
-}
-
-interface SizeDto {
-  readonly id: string;
-  readonly europe: SizeFormatDto;
-  readonly it: SizeFormatDto;
-  readonly lookiero: SizeFormatDto;
-  readonly uk: SizeFormatDto;
-}
-
-interface ToSizeFunction {
-  (size: SizeDto): Size;
-}
-
-const toSize: ToSizeFunction = (size) => ({
-  id: size.id,
-  europe: size.europe,
-  it: size.it,
-  lookiero: size.lookiero,
-  uk: size.uk,
-});
-
-interface ProductVariantDto {
-  readonly id: string;
-  readonly size: SizeDto;
-}
-
-interface ToProductVariantFunction {
-  (productVariant: ProductVariantDto): ProductVariant;
-}
-
-const toProductVariant: ToProductVariantFunction = (productVariant) => ({
-  id: productVariant.id,
-  size: toSize(productVariant.size),
-});
-
-interface BookedSizeReplaceableProductVariantsDto {
-  readonly booking: string | null;
-  readonly product_variants: ProductVariantDto[];
-}
-
-interface ToBookedSizeReplaceableProductVariantsFunction {
-  (
-    bookedSizeReplaceableProductVariants: BookedSizeReplaceableProductVariantsDto,
-  ): BookedSizeReplaceableProductVariantsProjection;
-}
-
-const toBookedSizeReplaceableProductVariants: ToBookedSizeReplaceableProductVariantsFunction = (
-  bookedSizeReplaceableProductVariants,
-) => ({
-  booking: bookedSizeReplaceableProductVariants.booking,
-  productVariants: bookedSizeReplaceableProductVariants.product_variants.map(toProductVariant),
-});
-
-interface HttpBookedSizeReplaceableProductVariantsForCheckoutItemView
-  extends BookedSizeReplaceableProductVariantsForCheckoutItemView {}
-
-interface HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunctionArgs {
-  readonly httpPost: HttpPostFunction;
-}
-
-interface HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunction {
-  (
-    args: HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunctionArgs,
-  ): HttpBookedSizeReplaceableProductVariantsForCheckoutItemView;
-}
-
-const httpBookedSizeReplaceableProductVariantsForCheckoutItemView: HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunction =
-
-    ({ httpPost }) =>
-    async ({ checkoutItemId }): Promise<BookedSizeReplaceableProductVariantsProjection | undefined> => {
-      try {
-        const response = await httpPost({
-          endpoint: "/view-booked-size-replaceable-product-variants-for-checkout-item",
-          body: { checkout_item_id: checkoutItemId },
-        });
-
-        return response.status === 404
-          ? undefined
-          : toBookedSizeReplaceableProductVariants((await response.json()).result);
-      } catch (ignored) {
-        throw new Error("Could not fetch BookedSizeReplaceableProductVariantsForCheckoutItem");
-      }
-    };
-
-export {
-  BookedSizeReplaceableProductVariantsDto,
-  toBookedSizeReplaceableProductVariants,
-  httpBookedSizeReplaceableProductVariantsForCheckoutItemView,
-};

package/src/infrastructure/projection/httpFirstAvailableCheckoutByCustomerIdView.test.ts

@@ -1,99 +0,0 @@
-import { v4 as uuid } from "uuid";
-import {
-  CheckoutItemStatus,
-  CheckoutStatus,
-  Currency,
-  MediaPerspective,
-} from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
-import {
-  CheckoutDto,
-  httpFirstAvailableCheckoutByCustomerIdView as sut,
-  toCheckoutProjection,
-} from "./httpFirstAvailableCheckoutByCustomerIdView";
-
-const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
-const checkoutResponse: { result: CheckoutDto } = {
-  result: {
-    id: uuid(),
-    status: CheckoutStatus.STARTED,
-    customer_id: uuid(),
-    box_id: uuid(),
-    booking_id: uuid(),
-    expires_on: "2022-09-20",
-    items: [
-      {
-        id: uuid(),
-        status: CheckoutItemStatus.KEPT,
-        product_variant: {
-          id: uuid(),
-          media: [
-            {
-              id: uuid(),
-              url: "https://cdn-catalog-back-prod.envs.lookiero.tech/d2/65/d2655b80-7745-4537-bb17-eb38f960a8de.jpg",
-              perspective: MediaPerspective.FRONT,
-            },
-          ],
-          brand: "CKS",
-          name: "Sari Tshirt lines",
-          price: {
-            amount: 3999,
-            currency: Currency.EUR,
-          },
-          size: {
-            id: uuid(),
-            lookiero: "M",
-            uk: "M",
-            it: "M",
-            europe: "M",
-            unique: false,
-          },
-          color: {
-            id: uuid(),
-            label: "black_C2",
-          },
-        },
-      },
-    ],
-  },
-};
-const checkoutResponseOk: Response = {
-  ok: true,
-  status: 200,
-  json: () => Promise.resolve(checkoutResponse),
-} as Response;
-const checkoutResponseNotFound: Response = {
-  ok: false,
-  status: 404,
-} as Response;
-const checkoutResponseError: Response = {
-  ok: false,
-} as Response;
-
-const httpPostMock = jest.fn();
-const view = sut({ httpPost: httpPostMock });
-
-describe("httpFirstAvailableCheckoutByCustomerIdView", () => {
-  it("returns a Checkout projection for a 200 response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(checkoutResponseOk));
-
-    const returnedCheckout = await view({ customerId });
-
-    expect(returnedCheckout).toStrictEqual(toCheckoutProjection(checkoutResponse.result));
-  });
-
-  it("returns undefined for a 404 response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(checkoutResponseNotFound));
-
-    const returnedCheckout = await view({ customerId });
-
-    expect(returnedCheckout).toBeUndefined();
-  });
-
-  it("returns undefined for a non successfull response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(checkoutResponseError));
-
-    const returnedCheckout = await view({ customerId });
-
-    expect(returnedCheckout).toBeUndefined();
-  });
-});

package/src/infrastructure/projection/httpFirstAvailableCheckoutByCustomerIdView.ts

@@ -1,128 +0,0 @@
-import {
-  CheckoutItemStatus,
-  CheckoutProjection,
-  CheckoutStatus,
-  Currency,
-  FirstAvailableCheckoutByCustomerIdView,
-  MediaPerspective,
-} from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
-import { HttpPostFunction } from "../delivery/http/httpClient";
-
-interface CheckoutDto {
-  readonly id: string;
-  readonly customer_id: string;
-  readonly box_id: string;
-  readonly booking_id: string;
-  readonly status: CheckoutStatus;
-  readonly expires_on: string;
-  readonly items: {
-    readonly id: string;
-    readonly status: CheckoutItemStatus;
-    readonly product_variant: {
-      readonly id: string;
-      readonly media: {
-        readonly id: string;
-        readonly url: string;
-        readonly perspective: MediaPerspective;
-      }[];
-      readonly brand: string;
-      readonly name: string;
-      readonly price: {
-        readonly amount: number;
-        readonly currency: Currency;
-        readonly discounted_price?: {
-          readonly amount: number;
-          readonly percentage: number;
-        };
-      };
-      readonly size: {
-        readonly id: string;
-        readonly lookiero: string;
-        readonly uk: string;
-        readonly it: string;
-        readonly europe: string;
-        readonly unique: boolean;
-        readonly visual_order?: number;
-      };
-      readonly color: {
-        readonly id: string;
-        readonly label: string;
-      };
-    };
-    readonly replaced_for?: string;
-  }[];
-}
-
-interface ToCheckoutProjectionFunction {
-  (checkoutDto: CheckoutDto): CheckoutProjection;
-}
-
-const toCheckoutProjection: ToCheckoutProjectionFunction = (checkoutDto) => ({
-  id: checkoutDto.id,
-  customerId: checkoutDto.customer_id,
-  boxId: checkoutDto.box_id,
-  bookingId: checkoutDto.booking_id,
-  status: checkoutDto.status,
-  expiresOn: new Date(checkoutDto.expires_on),
-  items: checkoutDto.items.map((item) => ({
-    id: item.id,
-    status: item.status,
-    replacedFor: item.replaced_for,
-    productVariant: {
-      id: item.product_variant.id,
-      media: item.product_variant.media.map((media) => ({
-        id: media.id,
-        url: media.url,
-        perspective: media.perspective,
-      })),
-      brand: item.product_variant.brand,
-      name: item.product_variant.name,
-      price: {
-        amount: item.product_variant.price.amount,
-        currency: item.product_variant.price.currency,
-        discountedPrice: item.product_variant.price.discounted_price
-          ? {
-              amount: item.product_variant.price.discounted_price.amount,
-              percentage: item.product_variant.price.discounted_price.percentage,
-            }
-          : undefined,
-      },
-      size: {
-        id: item.product_variant.size.id,
-        lookiero: item.product_variant.size.lookiero,
-        uk: item.product_variant.size.uk,
-        it: item.product_variant.size.it,
-        europe: item.product_variant.size.europe,
-        unique: item.product_variant.size.unique,
-        visualOrder: item.product_variant.size.visual_order,
-      },
-      color: {
-        id: item.product_variant.color.id,
-        label: item.product_variant.color.label,
-      },
-    },
-  })),
-});
-
-interface HttpFirstAvailableCheckoutByCustomerIdView extends FirstAvailableCheckoutByCustomerIdView {}
-
-interface HttpFirstAvailableCheckoutByCustomerIdViewFunctionArgs {
-  readonly httpPost: HttpPostFunction;
-}
-
-interface HttpFirstAvailableCheckoutByCustomerIdViewFunction {
-  (args: HttpFirstAvailableCheckoutByCustomerIdViewFunctionArgs): HttpFirstAvailableCheckoutByCustomerIdView;
-}
-
-const httpFirstAvailableCheckoutByCustomerIdView: HttpFirstAvailableCheckoutByCustomerIdViewFunction =
-  ({ httpPost }) =>
-  async ({ customerId }): Promise<CheckoutProjection | undefined> => {
-    const response = await httpPost({
-      endpoint: "/view-first-available-checkout-by-customer-id",
-      body: { customer_id: customerId },
-    });
-
-    return !response.ok || response.status === 404 ? undefined : toCheckoutProjection((await response.json()).result);
-  };
-
-export { CheckoutDto, toCheckoutProjection, httpFirstAvailableCheckoutByCustomerIdView };

package/src/infrastructure/projection/httpIsCheckoutEnabledByCustomerIdView.test.ts

@@ -1,32 +0,0 @@
-import { httpIsCheckoutEnabledByCustomerIdView as sut } from "./httpIsCheckoutEnabledByCustomerIdView";
-
-const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
-const checkoutResponseOk: Response = {
-  ok: true,
-  status: 200,
-  json: () => Promise.resolve(true),
-} as Response;
-const checkoutResponseError: Response = {
-  ok: false,
-} as Response;
-
-const httpGetMock = jest.fn();
-const view = sut({ httpGet: httpGetMock });
-
-describe("httpIsCheckoutEnabledByCustomerIdView", () => {
-  it("returns true/false if enabled/not for a 200 response", async () => {
-    httpGetMock.mockReturnValue(Promise.resolve(checkoutResponseOk));
-
-    const enabled = await view({ customerId });
-
-    expect(enabled).toBe(true);
-  });
-
-  it("returns false for a non successfull response", async () => {
-    httpGetMock.mockReturnValue(Promise.resolve(checkoutResponseError));
-
-    const enabled = await view({ customerId });
-
-    expect(enabled).toBe(false);
-  });
-});

package/src/infrastructure/projection/httpIsCheckoutEnabledByCustomerIdView.ts

@@ -1,27 +0,0 @@
-import {
-  IsCheckoutEnabledByCustomerIdProjection,
-  IsCheckoutEnabledByCustomerIdView,
-} from "../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
-import { HttpGetFunction } from "../delivery/http/httpClient";
-
-interface HttpIsCheckoutEnabledByCustomerIdView extends IsCheckoutEnabledByCustomerIdView {}
-
-interface HttpIsCheckoutEnabledByCustomerIdViewFunctionArgs {
-  readonly httpGet: HttpGetFunction;
-}
-
-interface HttpIsCheckoutEnabledByCustomerIdViewFunction {
-  (args: HttpIsCheckoutEnabledByCustomerIdViewFunctionArgs): HttpIsCheckoutEnabledByCustomerIdView;
-}
-
-const httpIsCheckoutEnabledByCustomerIdView: HttpIsCheckoutEnabledByCustomerIdViewFunction =
-  ({ httpGet }) =>
-  async ({ customerId }): Promise<IsCheckoutEnabledByCustomerIdProjection> => {
-    const response = await httpGet({
-      endpoint: `/is-new-checkout-enabled/${customerId}`,
-    });
-
-    return !response.ok ? false : await response.json();
-  };
-
-export { httpIsCheckoutEnabledByCustomerIdView };

package/src/infrastructure/projection/react/useViewBookedSizeReplaceableProductVariantsForCheckoutItem.test.ts

@@ -1,51 +0,0 @@
-import { bootstrap } from "@lookiero/messaging-react";
-import { renderHook } from "@testing-library/react-hooks";
-import {
-  BookedSizeReplaceableProductVariantsProjection,
-  viewBookedSizeReplaceableProductVariantsForCheckoutItemHandler,
-  VIEW_BOOKED_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM,
-} from "../../../projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem";
-import { useViewBookedSizeReplaceableProductVariantsForCheckoutItem } from "./useViewBookedSizeReplaceableProductVariantsForCheckoutItem";
-
-const checkoutItemId = "6f720954-8039-4bed-9596-34fc5a02131b";
-const bookedSizeReplaceableProductVariants: BookedSizeReplaceableProductVariantsProjection = {
-  booking: "b00e2c2d-7d9c-4808-88a4-e1c845ae6889",
-  productVariants: [
-    {
-      id: "383fab95-56eb-4639-bb18-530ab792b4d3",
-      size: {
-        id: "4f8a26b8-8d2d-4012-b49a-7d2820095598",
-        europe: { size: "36", format: "36" },
-        lookiero: { size: "S", format: "S" },
-        uk: { size: "8", format: "8" },
-        it: { size: "M", format: "M" },
-      },
-    },
-  ],
-};
-const view = jest.fn().mockReturnValue(bookedSizeReplaceableProductVariants);
-const { Component: Messaging } = bootstrap({ id: "Checkout" })
-  .query(
-    VIEW_BOOKED_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM,
-    viewBookedSizeReplaceableProductVariantsForCheckoutItemHandler,
-    {
-      view,
-    },
-  )
-  .build();
-
-describe("useViewBookedSizeReplaceableProductVariantsForCheckoutItem integration hook", () => {
-  it("returns success as the query status and the result itself after rendering the hook", async () => {
-    const { result, waitFor } = renderHook(
-      () => useViewBookedSizeReplaceableProductVariantsForCheckoutItem({ checkoutItemId }),
-      { wrapper: Messaging },
-    );
-
-    await waitFor(() => {
-      const [projection, status] = result.current;
-
-      expect(projection).toStrictEqual(bookedSizeReplaceableProductVariants);
-      expect(status).toBe("success");
-    });
-  });
-});

package/src/infrastructure/projection/react/useViewBookedSizeReplaceableProductVariantsForCheckoutItem.ts

@@ -1,25 +0,0 @@
-import { useQuery, UseQueryFunctionResult } from "@lookiero/messaging-react";
-import {
-  BookedSizeReplaceableProductVariantsProjection,
-  viewBookedSizeReplaceableProductVariantsForCheckoutItem,
-} from "../../../projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem";
-
-interface UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunctionArgs {
-  readonly checkoutItemId: string;
-}
-
-interface UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunction {
-  (
-    args: UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunctionArgs,
-  ): UseQueryFunctionResult<BookedSizeReplaceableProductVariantsProjection>;
-}
-
-const useViewBookedSizeReplaceableProductVariantsForCheckoutItem: UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunction =
-  ({ checkoutItemId }) =>
-    useQuery({
-      query: viewBookedSizeReplaceableProductVariantsForCheckoutItem({ checkoutItemId }),
-      contextId: "Checkout",
-      options: { staleTime: Infinity },
-    });
-
-export { useViewBookedSizeReplaceableProductVariantsForCheckoutItem };

package/src/infrastructure/projection/react/useViewCheckoutIntroShown.test.ts

@@ -1,41 +0,0 @@
-import { CommandStatus } from "@lookiero/messaging-react";
-import { renderHook } from "@testing-library/react-hooks";
-import { UiSettingProjection } from "../../../projection/uiSetting/viewUiSettingByKey";
-import { useViewCheckoutIntroShown as sut } from "./useViewCheckoutIntroShown";
-import { useViewUiSettingByKey } from "./useViewUiSettingByKey";
-
-jest.mock("./useViewUiSettingByKey");
-
-const uiSettingProjection: UiSettingProjection = {
-  id: "this-should-be-a-uuid",
-  key: "ui_setting_key",
-  value: "ui_setting_value",
-};
-
-describe("useViewCheckoutIntroShown integration hook", () => {
-  it("returns uiSetting after rendering the hook (existing ui setting key)", async () => {
-    (useViewUiSettingByKey as jest.Mock).mockReturnValue([uiSettingProjection, CommandStatus.SUCCESS]);
-
-    const { result, waitFor } = renderHook(() => sut());
-
-    await waitFor(() => {
-      const [projection, status] = result.current;
-
-      expect(projection).toStrictEqual(uiSettingProjection);
-      expect(status).toBe(CommandStatus.SUCCESS);
-    });
-  });
-
-  it("returns undefined after rendering the hook (non-existing ui setting key)", async () => {
-    (useViewUiSettingByKey as jest.Mock).mockReturnValue([undefined, CommandStatus.ERROR]);
-
-    const { result, waitFor } = renderHook(() => sut());
-
-    await waitFor(() => {
-      const [projection, status] = result.current;
-
-      expect(projection).toBeUndefined();
-      expect(status).toBe(CommandStatus.ERROR);
-    });
-  });
-});

package/src/infrastructure/projection/react/useViewCheckoutIntroShown.ts

@@ -1,9 +0,0 @@
-import { UISettings } from "../../ui/settings/UISettings";
-import { useViewUiSettingByKey } from "./useViewUiSettingByKey";
-
-const useViewCheckoutIntroShown = () =>
-  useViewUiSettingByKey({
-    key: UISettings.CHECKOUT_INTRO_SHOWN,
-  });
-
-export { useViewCheckoutIntroShown };