@lookiero/checkout 0.1.1 → 0.2.0

package/src/infrastructure/delivery/http/fetchHttpClient.test.ts

@@ -1,51 +0,0 @@
-import { fetchHttpGet as sutGet, fetchHttpPost as sutPost } from "./fetchHttpClient";
-
-const fetchMock = jest.fn();
-global.fetch = fetchMock;
-
-const apiUrl = "/api";
-const authToken = "token";
-const post = sutPost({ apiUrl, getAuthToken: () => authToken });
-const get = sutGet({ apiUrl, getAuthToken: () => authToken });
-
-afterEach(() => {
-  fetchMock.mockClear();
-});
-
-describe("fetchHttpClient", () => {
-  it("does a POST http request with the expected parameters", async () => {
-    const endpoint = "/dummy-endpoint";
-    const body = { foo: "bar" };
-    const expectedEndpoint = `${apiUrl}${endpoint}`;
-    const expectedPayload = {
-      method: "POST",
-      headers: {
-        ["Content-Type"]: "application/json",
-        authorization: `Bearer ${authToken}`,
-      },
-      body: JSON.stringify(body),
-    };
-
-    await post({ endpoint, body });
-
-    expect(fetchMock).toHaveBeenCalledWith(expectedEndpoint, expectedPayload);
-  });
-
-  it("does a GET http request with the expected parameters", async () => {
-    const endpoint = "/dummy-endpoint";
-    const expectedEndpoint = `${apiUrl}${endpoint}`;
-    const expectedPayload = {
-      method: "GET",
-      credentials: "include",
-      mode: "no-cors",
-      headers: {
-        authorization: `Bearer ${authToken}`,
-      },
-      referrer: "",
-    };
-
-    await get({ endpoint });
-
-    expect(fetchMock).toHaveBeenCalledWith(expectedEndpoint, expectedPayload);
-  });
-});

package/src/infrastructure/delivery/http/fetchHttpClient.ts

@@ -1,41 +0,0 @@
-import { HttpGetFunction, HttpPostFunction } from "./httpClient";
-
-interface FetchHttpFunctionArgs {
-  readonly apiUrl: string;
-  readonly getAuthToken: () => string;
-}
-
-interface FetchHttpPostFunction {
-  (args: FetchHttpFunctionArgs): HttpPostFunction;
-}
-
-interface FetchHttpGetFunction {
-  (args: FetchHttpFunctionArgs): HttpGetFunction;
-}
-
-const fetchHttpPost: FetchHttpPostFunction =
-  ({ apiUrl, getAuthToken }) =>
-  async ({ endpoint, body }) =>
-    fetch(`${apiUrl}${endpoint}`, {
-      method: "POST",
-      headers: {
-        ["Content-Type"]: "application/json",
-        authorization: `Bearer ${getAuthToken()}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-const fetchHttpGet: FetchHttpGetFunction =
-  ({ apiUrl, getAuthToken }) =>
-  async ({ endpoint }) =>
-    fetch(`${apiUrl}${endpoint}`, {
-      method: "GET",
-      credentials: "include",
-      mode: "no-cors",
-      headers: {
-        authorization: `Bearer ${getAuthToken()}`,
-      },
-      referrer: "",
-    });
-
-export { fetchHttpGet, fetchHttpPost };

package/src/infrastructure/delivery/http/httpClient.ts

@@ -1,18 +0,0 @@
-interface HttpGetFunctionArgs {
-  readonly endpoint: string;
-}
-
-interface HttpGetFunction {
-  (args: HttpGetFunctionArgs): Promise<Response>;
-}
-
-interface HttpPostFunctionArgs {
-  readonly endpoint: string;
-  readonly body: Record<string, unknown>;
-}
-
-interface HttpPostFunction {
-  (args: HttpPostFunctionArgs): Promise<Response>;
-}
-
-export { HttpGetFunction, HttpPostFunction };

package/src/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.test.ts

@@ -1,45 +0,0 @@
-import { v4 as uuid } from "uuid";
-import { saveCheckoutBooking as sut } from "./httpCheckoutBookings";
-
-const saveCheckoutBookingResponseOk: Response = {
-  ok: true,
-} as Response;
-const saveCheckoutBookingResponseError: Response = {
-  ok: false,
-} as Response;
-
-const httpPostMock = jest.fn();
-
-const checkoutBooking = {
-  checkoutId: "this-should-be-a-uuid",
-  checkoutItemId: "this-should-be-a-uuid",
-  checkoutBookingId: "this-should-be-a-uuid",
-};
-
-describe("httpCheckoutBookings", () => {
-  it("saveCheckoutBooking: calls '/book-size-replaceable-product-variants-for-checkout-item' endpoint", async () => {
-    const expectedEndpoint = "/book-size-replaceable-product-variants-for-checkout-item";
-    httpPostMock.mockReturnValue(Promise.resolve(saveCheckoutBookingResponseOk));
-
-    const checkoutBookingsSave = { aggregateId: uuid(), ...checkoutBooking, domainEvents: [] };
-
-    await sut({ httpPost: httpPostMock })(checkoutBookingsSave);
-
-    expect(httpPostMock).toBeCalledWith({
-      endpoint: expectedEndpoint,
-      body: {
-        checkout_id: checkoutBooking.checkoutId,
-        checkout_item_id: checkoutBooking.checkoutItemId,
-        checkout_booking_id: checkoutBooking.checkoutBookingId,
-      },
-    });
-  });
-
-  it("saveCheckoutBooking: throws for an unsuccessfull response", async () => {
-    httpPostMock.mockReturnValue(Promise.resolve(saveCheckoutBookingResponseError));
-
-    const checkoutBookingsSave = { aggregateId: uuid(), ...checkoutBooking, domainEvents: [] };
-
-    await expect(sut({ httpPost: httpPostMock })(checkoutBookingsSave)).rejects.toThrow();
-  });
-});

package/src/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.ts

@@ -1,32 +0,0 @@
-import { CheckoutBookingsSaveFunction } from "../../../../domain/checkoutBooking/model/checkoutBookings";
-import { HttpPostFunction } from "../../../delivery/http/httpClient";
-
-interface HttpCheckoutBookingsSaveFunctionArgs {
-  readonly httpPost: HttpPostFunction;
-}
-
-interface HttpCheckoutBookingsSaveFunction {
-  (args: HttpCheckoutBookingsSaveFunctionArgs): CheckoutBookingsSaveFunction;
-}
-
-export const saveCheckoutBooking: HttpCheckoutBookingsSaveFunction =
-  ({ httpPost }) =>
-  async ({ checkoutId, checkoutItemId, checkoutBookingId }) => {
-    try {
-      const response = await httpPost({
-        endpoint: "/book-size-replaceable-product-variants-for-checkout-item",
-        body: {
-          checkout_id: checkoutId,
-          checkout_item_id: checkoutItemId,
-          checkout_booking_id: checkoutBookingId,
-        },
-      });
-
-      if (!response.ok) {
-        throw new Error("Book size replaceable product variants for checkout item");
-      }
-      return;
-    } catch (ignored) {
-      throw new Error("Could not fetch BookSizeReplaceableProductVariantsForCheckoutItem");
-    }
-  };

package/src/infrastructure/domain/react/useBookSizeReplaceableProductVariantsForCheckoutItem.test.ts

@@ -1,38 +0,0 @@
-import { bootstrap, CommandStatus } from "@lookiero/messaging-react";
-import { act, renderHook } from "@testing-library/react-hooks";
-import { BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM } from "../../../domain/checkoutBooking/command/bookSizeReplaceableProductVariantsForCheckoutItem";
-import { bookSizeReplaceableProductVariantsForCheckoutItemHandler } from "../../../domain/checkoutBooking/model/checkoutBooking";
-import { useBookSizeReplaceableProductVariantsForCheckoutItem as sut } from "./useBookSizeReplaceableProductVariantsForCheckoutItem";
-
-const checkoutBooking = {
-  checkoutId: "this-should-be-a-uuid",
-  checkoutItemId: "this-should-be-a-uuid",
-  checkoutBookingId: "this-should-be-a-uuid",
-};
-
-const saveMock = jest.fn();
-const { Component: Messaging } = bootstrap()
-  .command(
-    BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM,
-    bookSizeReplaceableProductVariantsForCheckoutItemHandler,
-    {
-      get: jest.fn(),
-      save: saveMock,
-    },
-  )
-  .build();
-
-describe("useBookSizeReplaceableProductVariantsForCheckoutItem integration hook", () => {
-  it("returns success as the status right after calling 'book'", async () => {
-    saveMock.mockResolvedValue("success");
-    const { result, waitFor } = renderHook(() => sut({ ...checkoutBooking }), { wrapper: Messaging });
-
-    expect(result.current.status).toBe(CommandStatus.IDLE);
-
-    await act(() => result.current.book());
-
-    await waitFor(() => {
-      expect(result.current.status).toBe(CommandStatus.SUCCESS);
-    });
-  });
-});

package/src/infrastructure/domain/react/useBookSizeReplaceableProductVariantsForCheckoutItem.ts

@@ -1,44 +0,0 @@
-import { CommandStatus, useCommand } from "@lookiero/messaging-react";
-import { useCallback } from "react";
-import { v4 as uuid } from "uuid";
-import { bookSizeReplaceableProductVariantsForCheckoutItem } from "../../../domain/checkoutBooking/command/bookSizeReplaceableProductVariantsForCheckoutItem";
-
-interface UseBookSizeReplaceableProductVariantsForCheckoutItem {
-  readonly book: () => Promise<void>;
-  readonly status: CommandStatus;
-}
-
-interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs {
-  readonly checkoutId: string;
-  readonly checkoutItemId: string;
-  readonly checkoutBookingId: string;
-}
-
-interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunction {
-  (
-    args: UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs,
-  ): UseBookSizeReplaceableProductVariantsForCheckoutItem;
-}
-
-export const useBookSizeReplaceableProductVariantsForCheckoutItem: UseBookSizeReplaceableProductVariantsForCheckoutItemFunction =
-  ({ checkoutId, checkoutItemId, checkoutBookingId }) => {
-    const [commandBus, status] = useCommand();
-
-    const book = useCallback(
-      async () =>
-        await commandBus(
-          bookSizeReplaceableProductVariantsForCheckoutItem({
-            aggregateId: uuid(),
-            checkoutId,
-            checkoutItemId,
-            checkoutBookingId,
-          }),
-        ),
-      [checkoutBookingId, checkoutId, checkoutItemId, commandBus],
-    );
-
-    return {
-      book,
-      status,
-    };
-  };

package/src/infrastructure/domain/react/useUpdateUiSetting.test.ts

@@ -1,31 +0,0 @@
-import { bootstrap, CommandStatus } from "@lookiero/messaging-react";
-import { act, renderHook } from "@testing-library/react-hooks";
-import { UPDATE_UI_SETTING } from "../../../domain/uiSetting/command/updateUiSetting";
-import { updateUiSettingHandler } from "../../../domain/uiSetting/model/uiSetting";
-import { useUpdateUiSetting as sut } from "./useUpdateUiSetting";
-
-const uiSettingKey = "ui_setting_key";
-const uiSettingValue = "ui_setting_value";
-
-const saveMock = jest.fn();
-const { Component: Messaging } = bootstrap()
-  .command(UPDATE_UI_SETTING, updateUiSettingHandler, {
-    get: jest.fn(),
-    save: saveMock,
-  })
-  .build();
-
-describe("useUpdateUiSetting integration hook", () => {
-  it("returns success as the status right after calling 'update'", async () => {
-    saveMock.mockResolvedValue("success");
-    const { result, waitFor } = renderHook(() => sut(), { wrapper: Messaging });
-
-    expect(result.current.status).toBe(CommandStatus.IDLE);
-
-    await act(() => result.current.update({ key: uiSettingKey, value: uiSettingValue }));
-
-    await waitFor(() => {
-      expect(result.current.status).toBe(CommandStatus.SUCCESS);
-    });
-  });
-});

package/src/infrastructure/domain/react/useUpdateUiSetting.ts

@@ -1,43 +0,0 @@
-import { CommandStatus, useCommand } from "@lookiero/messaging-react";
-import { useCallback } from "react";
-import { v4 as uuid } from "uuid";
-import { updateUiSetting } from "../../../domain/uiSetting/command/updateUiSetting";
-
-interface UpdateFunctionArgs {
-  readonly key: string;
-  readonly value: unknown;
-}
-
-interface UpdateFunction {
-  (args: UpdateFunctionArgs): Promise<void>;
-}
-
-interface UseUpdateUiSetting {
-  readonly update: UpdateFunction;
-  readonly status: CommandStatus;
-}
-
-interface UseUpdateUiSettingFunction {
-  (): UseUpdateUiSetting;
-}
-
-export const useUpdateUiSetting: UseUpdateUiSettingFunction = () => {
-  const [commandBus, status] = useCommand();
-
-  const update: UpdateFunction = useCallback(
-    async ({ key, value }) =>
-      await commandBus(
-        updateUiSetting({
-          aggregateId: uuid(),
-          key,
-          value,
-        }),
-      ),
-    [commandBus],
-  );
-
-  return {
-    update,
-    status,
-  };
-};

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

@@ -1,50 +0,0 @@
-import { v4 as uuid } from "uuid";
-import { getUiSetting as getSut, saveUiSetting as saveSut } from "./storageUiSettings";
-
-const readMock = jest.fn();
-const writeMock = jest.fn();
-
-describe("storageUiSettings", () => {
-  it("gets uiSetting based on the given ui setting key", async () => {
-    const aggregateId = uuid();
-    const uiSettingKey = "ui_setting_key";
-    const uiSettingValue = "ui_setting_value";
-
-    readMock.mockReturnValue({
-      id: aggregateId,
-      key: uiSettingKey,
-      value: uiSettingValue,
-    });
-
-    const getResponse = await getSut({ read: readMock })(uiSettingKey);
-
-    expect(getResponse).toEqual({ aggregateId, key: uiSettingKey, value: uiSettingValue, domainEvents: [] });
-  });
-
-  it("throws an Error when uiSetting based on the given ui setting key does not exist", async () => {
-    const uiSettingKey = "ui_setting_key";
-
-    readMock.mockReturnValue(undefined);
-
-    await expect(getSut({ read: readMock })(uiSettingKey)).rejects.toThrow();
-  });
-
-  it("saves the given uiSetting", async () => {
-    const aggregateId = uuid();
-    const uiSettingKey = "ui_setting_key";
-    const uiSettingValue = "ui_setting_value";
-
-    const uiSettingDto = { aggregateId, key: uiSettingKey, value: uiSettingValue };
-    const uiSetting = { ...uiSettingDto, domainEvents: [] };
-
-    writeMock.mockResolvedValue("success");
-
-    await saveSut({ write: writeMock })(uiSetting);
-
-    expect(writeMock).toHaveBeenCalledWith(uiSettingKey, {
-      id: aggregateId,
-      key: uiSettingKey,
-      value: uiSettingValue,
-    });
-  });
-});

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

@@ -1,50 +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;
-}
-
-export 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;
-}
-
-export const saveUiSetting: StorageUiSettingsSaveFunction =
-  ({ write }) =>
-  async (aggregateRoot) =>
-    await write(aggregateRoot.key, fromDomain(aggregateRoot));

package/src/infrastructure/persistence/asyncStorageStorage.ts

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

package/src/infrastructure/persistence/storage.ts

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

package/src/infrastructure/persistence/uiSettingData.ts

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

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