@lookiero/checkout 5.3.0 → 6.0.0-beta.0

package/src/infrastructure/projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId.ts

@@ -0,0 +1,49 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { useQuery, UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { isCheckoutStarted } from "../../../../domain/checkout/model/checkoutStarted";
+import { isCheckoutSubmitted } from "../../../../domain/checkout/model/checkoutSubmitted";
+import { isCheckoutBookingBooked } from "../../../../domain/checkoutBooking/model/checkoutBookingBooked";
+import { isCheckoutBookingExpired } from "../../../../domain/checkoutBooking/model/checkoutBookingExpired";
+import { isCheckoutFeedbackGiven } from "../../../../domain/checkoutFeedback/model/checkoutFeedbackGiven";
+import { isCheckoutItemKept } from "../../../../domain/checkoutItem/model/checkoutItemKept";
+import { isCheckoutItemReplaced } from "../../../../domain/checkoutItem/model/checkoutItemReplaced";
+import { isCheckoutItemReset } from "../../../../domain/checkoutItem/model/checkoutItemReset";
+import { isCheckoutItemReturned } from "../../../../domain/checkoutItem/model/checkoutItemReturned";
+import { CheckoutProjection } from "../../../../projection/checkout/checkout";
+import { viewFirstAvailableCheckoutByCustomerId } from "../../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+
+const shouldInvalidate = (event: DomainEvent<MessageName>) =>
+  isCheckoutItemKept(event) ||
+  isCheckoutItemReplaced(event) ||
+  isCheckoutItemReturned(event) ||
+  isCheckoutItemReset(event) ||
+  isCheckoutStarted(event) ||
+  isCheckoutSubmitted(event) ||
+  isCheckoutFeedbackGiven(event) ||
+  isCheckoutBookingBooked(event) ||
+  isCheckoutBookingExpired(event);
+
+interface UseViewFirstAvailableCheckoutByCustomerIdFunctionArgs {
+  readonly customerId: string;
+}
+
+interface UseViewFirstAvailableCheckoutByCustomerIdFunction {
+  (args: UseViewFirstAvailableCheckoutByCustomerIdFunctionArgs): UseQueryFunctionResult<CheckoutProjection>;
+}
+
+const useViewFirstAvailableCheckoutByCustomerId: UseViewFirstAvailableCheckoutByCustomerIdFunction = ({ customerId }) =>
+  useQuery({
+    query: viewFirstAvailableCheckoutByCustomerId({ customerId }),
+    contextId: MESSAGING_CONTEXT_ID,
+    invalidation: shouldInvalidate,
+    options: {
+      refetchOnMount: "always",
+      staleTime: Infinity,
+      retry: false,
+      refetchOnWindowFocus: false,
+      cacheTime: 0,
+    },
+  });
+
+export { useViewFirstAvailableCheckoutByCustomerId };

package/src/infrastructure/projection/checkout/react/useViewFiveItemsDiscountByCustomerId.test.ts

@@ -0,0 +1,28 @@
+import { renderHook, waitFor } from "@testing-library/react-native";
+import { bootstrap, QueryStatus } from "@lookiero/messaging-react";
+import {
+  viewFiveItemsDiscountByCustomerIdHandler,
+  VIEW_FIVE_ITEMS_DISCOUNT_BY_CUSTOMER_ID,
+} from "../../../../projection/checkout/viewFiveItemsDiscountByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+import { useViewFiveItemsDiscountByCustomerId as sut } from "./useViewFiveItemsDiscountByCustomerId";
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const fiveItemsDiscount = 25;
+const view = jest.fn().mockReturnValue(fiveItemsDiscount);
+const { Component: Messaging } = bootstrap({ id: MESSAGING_CONTEXT_ID })
+  .query(VIEW_FIVE_ITEMS_DISCOUNT_BY_CUSTOMER_ID, viewFiveItemsDiscountByCustomerIdHandler, { view })
+  .build();
+
+describe("useViewFiveItemsDiscountByCustomerId integration hook", () => {
+  it("returns success as the query status and the result itself after rendering the hook", async () => {
+    const { result } = renderHook(() => sut({ customerId }), { wrapper: Messaging });
+
+    await waitFor(() => {
+      const [projection, status] = result.current;
+
+      expect(projection).toStrictEqual(fiveItemsDiscount);
+      expect(status).toBe(QueryStatus.SUCCESS);
+    });
+  });
+});

package/src/infrastructure/projection/checkout/react/useViewFiveItemsDiscountByCustomerId.ts

@@ -0,0 +1,25 @@
+import { useQuery, UseQueryFunctionResult } from "@lookiero/messaging-react";
+import {
+  FiveItemsDiscountByCustomerIdProjection,
+  viewFiveItemsDiscountByCustomerId,
+} from "../../../../projection/checkout/viewFiveItemsDiscountByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+
+interface UseViewFiveItemsDiscountByCustomerIdFunctionArgs {
+  readonly customerId: string;
+}
+
+interface UseViewFiveItemsDiscountByCustomerIdFunction {
+  (
+    args: UseViewFiveItemsDiscountByCustomerIdFunctionArgs,
+  ): UseQueryFunctionResult<FiveItemsDiscountByCustomerIdProjection>;
+}
+
+const useViewFiveItemsDiscountByCustomerId: UseViewFiveItemsDiscountByCustomerIdFunction = ({ customerId }) =>
+  useQuery({
+    query: viewFiveItemsDiscountByCustomerId({ customerId }),
+    contextId: MESSAGING_CONTEXT_ID,
+    options: { staleTime: Infinity },
+  });
+
+export { useViewFiveItemsDiscountByCustomerId };

package/src/infrastructure/projection/checkout/react/useViewIsCheckoutAccessibleByCustomerId.test.ts

@@ -0,0 +1,45 @@
+import { renderHook, waitFor } from "@testing-library/react-native";
+import { bootstrap, QueryStatus } from "@lookiero/messaging-react";
+import { CheckoutProjection } from "../../../../projection/checkout/checkout";
+import {
+  viewFirstAvailableCheckoutByCustomerIdHandler,
+  VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID,
+} from "../../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import {
+  viewIsCheckoutAccessibleByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID,
+} from "../../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import {
+  viewIsCheckoutEnabledByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID,
+} from "../../../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+import { useViewIsCheckoutAccessibleByCustomerId as sut } from "./useViewIsCheckoutAccessibleByCustomerId";
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutProjection: CheckoutProjection = { id: "75574065-5838-42de-9924-c712f7854347" } as CheckoutProjection;
+const firstAvailableCheckoutByCustomerIdViewMock = jest.fn().mockReturnValue(checkoutProjection);
+const isCheckoutAccessibleByCustomerIdViewMock = jest.fn().mockReturnValue(checkoutProjection);
+
+const { Component: Messaging } = bootstrap({ id: MESSAGING_CONTEXT_ID })
+  .query(VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, viewFirstAvailableCheckoutByCustomerIdHandler, {
+    view: firstAvailableCheckoutByCustomerIdViewMock,
+  })
+  .query(VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, viewIsCheckoutEnabledByCustomerIdHandler, {
+    view: isCheckoutAccessibleByCustomerIdViewMock,
+  })
+  .query(VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, viewIsCheckoutAccessibleByCustomerIdHandler)
+  .build();
+
+describe("useViewIsCheckoutAccessibleByCustomerId integration hook", () => {
+  it("returns success as the query status and the result itself after rendering the hook", async () => {
+    const { result } = renderHook(() => sut({ customerId }), { wrapper: Messaging });
+
+    await waitFor(() => {
+      const [projection, status] = result.current;
+
+      expect(projection).toBe(true);
+      expect(status).toBe(QueryStatus.SUCCESS);
+    });
+  });
+});

package/src/infrastructure/projection/checkout/react/useViewIsCheckoutAccessibleByCustomerId.ts

@@ -0,0 +1,33 @@
+import { useQuery, UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { isCheckoutFeedbackGiven } from "../../../../domain/checkoutFeedback/model/checkoutFeedbackGiven";
+import {
+  IsCheckoutAccessibleByCustomerIdProjection,
+  viewIsCheckoutAccessibleByCustomerId,
+} from "../../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+
+interface UseViewIsCheckoutAccessibleByCustomerIdFunctionArgs {
+  readonly customerId: string | undefined;
+}
+
+interface UseViewIsCheckoutAccessibleByCustomerIdFunction {
+  (
+    args: UseViewIsCheckoutAccessibleByCustomerIdFunctionArgs,
+  ): UseQueryFunctionResult<IsCheckoutAccessibleByCustomerIdProjection>;
+}
+
+const useViewIsCheckoutAccessibleByCustomerId: UseViewIsCheckoutAccessibleByCustomerIdFunction = ({ customerId }) =>
+  useQuery({
+    query: viewIsCheckoutAccessibleByCustomerId({ customerId }),
+    contextId: MESSAGING_CONTEXT_ID,
+    invalidation: isCheckoutFeedbackGiven,
+    options: {
+      refetchOnMount: "always",
+      staleTime: Infinity,
+      retry: false,
+      refetchOnWindowFocus: false,
+      cacheTime: 0,
+    },
+  });
+
+export { useViewIsCheckoutAccessibleByCustomerId };

package/src/infrastructure/projection/checkout/react/useViewIsSizeChangeEnabledByCheckoutId.test.ts

@@ -0,0 +1,41 @@
+import { renderHook, waitFor } from "@testing-library/react-native";
+import { bootstrap, QueryStatus } from "@lookiero/messaging-react";
+import {
+  viewIsSizeChangeEnabledByCheckoutIdHandler,
+  VIEW_IS_SIZE_CHANGE_ENABLED_BY_CHECKOUT_ID,
+} from "../../../../projection/checkout/viewIsSizeChangeEnabledByCheckoutId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+import { useViewIsSizeChangeEnabledByCheckoutId as sut } from "./useViewIsSizeChangeEnabledByCheckoutId";
+
+const checkoutId = "29790d24-b139-4ab8-b618-d796d101e974";
+const isSizeChangeEnabledByCheckoutIdViewMock = jest.fn().mockReturnValue(true);
+
+const { Component: Messaging } = bootstrap({ id: MESSAGING_CONTEXT_ID })
+  .query(VIEW_IS_SIZE_CHANGE_ENABLED_BY_CHECKOUT_ID, viewIsSizeChangeEnabledByCheckoutIdHandler, {
+    view: isSizeChangeEnabledByCheckoutIdViewMock,
+  })
+  .build();
+
+describe("useViewIsSizeChangeEnabledByCheckoutId integration hook", () => {
+  it("returns success as the query status and the result itself after rendering the hook", async () => {
+    const { result } = renderHook(() => sut({ checkoutId }), { wrapper: Messaging });
+
+    await waitFor(() => {
+      const [projection, status] = result.current;
+
+      expect(projection).toBe(true);
+      expect(status).toBe(QueryStatus.SUCCESS);
+    });
+  });
+
+  it("does not ask the query if the checkoutId is not defined", async () => {
+    const { result } = renderHook(() => sut({ checkoutId: undefined }), { wrapper: Messaging });
+
+    await waitFor(() => {
+      const [projection, status] = result.current;
+
+      expect(projection).toBe(undefined);
+      expect(status).toBe(QueryStatus.IDLE);
+    });
+  });
+});

package/src/infrastructure/projection/checkout/react/useViewIsSizeChangeEnabledByCheckoutId.ts

@@ -0,0 +1,30 @@
+import { useQuery, UseQueryFunctionResult } from "@lookiero/messaging-react";
+import {
+  IsSizeChangeEnabledByCheckoutIdProjection,
+  viewIsSizeChangeEnabledByCheckoutId,
+} from "../../../../projection/checkout/viewIsSizeChangeEnabledByCheckoutId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+
+interface UseViewIsSizeChangeEnabledByCheckoutIdFunctionArgs {
+  readonly checkoutId: string | undefined;
+}
+
+interface UseViewIsSizeChangeEnabledByCheckoutIdFunction {
+  (
+    args: UseViewIsSizeChangeEnabledByCheckoutIdFunctionArgs,
+  ): UseQueryFunctionResult<IsSizeChangeEnabledByCheckoutIdProjection>;
+}
+
+const useViewIsSizeChangeEnabledByCheckoutId: UseViewIsSizeChangeEnabledByCheckoutIdFunction = ({ checkoutId }) =>
+  useQuery({
+    query: viewIsSizeChangeEnabledByCheckoutId({ checkoutId: checkoutId as string }),
+    contextId: MESSAGING_CONTEXT_ID,
+    options: {
+      staleTime: Infinity,
+      retry: false,
+      refetchOnWindowFocus: false,
+      enabled: Boolean(checkoutId),
+    },
+  });
+
+export { useViewIsSizeChangeEnabledByCheckoutId };

package/src/infrastructure/projection/checkoutBooking/checkoutBooking.mock.ts

@@ -0,0 +1,9 @@
+import { CheckoutBookingProjection } from "../../../projection/checkoutBooking/checkoutBooking";
+
+const checkoutBooking: CheckoutBookingProjection = {
+  id: "e38f6e6d-a729-493b-aa4a-b1b325aa3092",
+  checkoutItemIds: ["3bcf99f9-9f5f-43c0-bc01-706549eb84dc"],
+  isExpired: false,
+};
+
+export { checkoutBooking };

package/src/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.pact.ts

@@ -0,0 +1,61 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { CheckoutBookingProjection } from "../../../projection/checkoutBooking/checkoutBooking";
+import { checkoutBooking as checkoutBookingMock } from "./checkoutBooking.mock";
+import { httpCheckoutBookingByIdView } from "./httpCheckoutBookingByIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewCheckoutBookingById",
+});
+
+const checkoutBookingProjection = checkoutBookingMock;
+const checkoutBookingId = checkoutBookingProjection.id;
+
+const checkoutBookingResponse: { result: CheckoutBookingProjection } = {
+  result: checkoutBookingProjection,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutBookingResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewCheckoutBookingById API", () => {
+  it("returns a valid checkout booking for the given id", () => {
+    provider
+      .given("a valid checkout booking for the given id")
+      .uponReceiving("checkout booking projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-checkout-booking-by-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutBookingId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+      });
+
+      const response = await httpCheckoutBookingByIdView({ httpPost })({
+        checkoutBookingId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(checkoutBookingResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.test.ts

@@ -0,0 +1,56 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import { CheckoutBookingProjection } from "../../../projection/checkoutBooking/checkoutBooking";
+import { checkoutBooking as checkoutBookingMock } from "./checkoutBooking.mock";
+import { httpCheckoutBookingByIdView as sut } from "./httpCheckoutBookingByIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpPost: fetchHttpPost({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const checkoutBookingProjection = checkoutBookingMock;
+const checkoutBookingId = checkoutBookingProjection.id;
+const checkoutBookingResponse: { result: CheckoutBookingProjection } = {
+  result: checkoutBookingProjection,
+};
+const checkoutBookingResponseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(checkoutBookingResponse)),
+} as Response;
+const checkoutBookingResponseNotFound: Response = {
+  ok: false,
+  status: 404,
+} as Response;
+const checkoutBookingResponseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpCheckoutBookingByIdView", () => {
+  it("returns a CheckoutBooking projection for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutBookingResponseOk));
+
+    const returnedCheckoutBooking = await view({ checkoutBookingId, signal });
+
+    expect(returnedCheckoutBooking).toStrictEqual(checkoutBookingResponse.result);
+  });
+
+  it("returns null for a 404 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutBookingResponseNotFound));
+
+    const returnedCheckoutBooking = await view({ checkoutBookingId, signal });
+
+    expect(returnedCheckoutBooking).toBeNull();
+  });
+
+  it("returns null for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutBookingResponseError));
+
+    const returnedCheckoutBooking = await view({ checkoutBookingId, signal });
+
+    expect(returnedCheckoutBooking).toBeNull();
+  });
+});

package/src/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.ts

@@ -0,0 +1,34 @@
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import {
+  CheckoutBookingByIdView,
+  ViewCheckoutBookingByIdResult,
+} from "../../../projection/checkoutBooking/viewCheckoutBookingById";
+
+interface HttpCheckoutBookingByIdView extends CheckoutBookingByIdView {}
+
+interface HttpCheckoutBookingByIdViewFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpCheckoutBookingByIdViewFunction {
+  (args: HttpCheckoutBookingByIdViewFunctionArgs): HttpCheckoutBookingByIdView;
+}
+
+interface ViewCheckoutBookingByIdResponse {
+  readonly result: ViewCheckoutBookingByIdResult;
+}
+
+const httpCheckoutBookingByIdView: HttpCheckoutBookingByIdViewFunction =
+  ({ httpPost }) =>
+  async ({ checkoutBookingId, signal }) =>
+    await httpPost<ViewCheckoutBookingByIdResponse, ViewCheckoutBookingByIdResult>({
+      endpoint: "/view-checkout-booking-by-id",
+      body: { checkoutBookingId },
+      signal,
+      result: {
+        error: null,
+        success: (response) => response.result,
+      },
+    });
+
+export { httpCheckoutBookingByIdView };

package/src/infrastructure/projection/checkoutFeedback/checkoutFeedback.mock.ts

@@ -0,0 +1,8 @@
+import { CheckoutFeedbackProjection } from "../../../projection/checkoutFeedback/checkoutFeedback";
+
+const checkoutFeedback: CheckoutFeedbackProjection = {
+  ["efe07b97-f6fb-4b6a-ba92-b68519320b2c"]: "68c0bb98-b00a-4b86-af43-528fe903cb69",
+  ["6a6d3878-5561-412c-96f3-7ed79ee587bb"]: "7970edd3-fb5c-42d3-afe3-ce31bcbb856c",
+};
+
+export { checkoutFeedback };

package/src/infrastructure/projection/checkoutItem/checkoutItem.mock.ts

@@ -0,0 +1,68 @@
+import { CheckoutItemStatus } from "../../../domain/checkoutItem/model/checkoutItem";
+import { Currency } from "../../../domain/checkoutItem/model/currency";
+import {
+  CheckoutItemProductVariantProjection,
+  CheckoutItemProjection,
+  MediaPerspective,
+} from "../../../projection/checkoutItem/checkoutItem";
+import { FeedbackProjection } from "../../../projection/feedback/feedback";
+
+interface CheckoutItemFunctionArgs {
+  readonly id?: string;
+  readonly status: CheckoutItemStatus;
+  readonly feedbacks?: FeedbackProjection;
+  readonly replacedFor?: CheckoutItemProductVariantProjection;
+}
+
+interface CheckoutItemFunction {
+  (args: CheckoutItemFunctionArgs): CheckoutItemProjection;
+}
+
+const checkoutItem: CheckoutItemFunction = ({
+  id = "7b389d69-f157-4234-8531-c1a1eb17dccb",
+  status,
+  feedbacks = {},
+  replacedFor = null,
+}) => ({
+  id,
+  status,
+  price: {
+    amount: 3999,
+    currency: Currency.EUR,
+  },
+  feedbacks,
+  productVariant: {
+    id: "7b389d69-f157-4234-8531-c1a1eb17dccb",
+    media: [
+      {
+        id: "d7ec731b-4123-4394-829b-297b952e73e5",
+        url: "https://cdn-catalog-back-prod.envs.lookiero.tech/1a/28/1a28f712-a76c-4172-8a11-f15002981dc0.jpg",
+        perspective: MediaPerspective.MAIN,
+      },
+      {
+        id: "8055e209-2fe9-44c5-b715-b09ad3ef741c",
+        url: "https://cdn-catalog-back-prod.envs.lookiero.tech/15/ac/15aca112-4e71-4646-8db5-7f9723bc0130.jpg",
+        perspective: MediaPerspective.DETAIL,
+      },
+    ],
+    brand: "CKS",
+    name: "Sari Tshirt lines",
+    size: {
+      id: "b26f7190-d505-4d24-aeb9-ad36e5e6ec4b",
+      lookiero: "M",
+      uk: "M",
+      it: "M",
+      europe: "M",
+      unique: false,
+    },
+    color: {
+      id: "c228d1b0-d06d-4d5c-a7d5-953fd43af0d8",
+      name: "black",
+      label: "black_C2",
+    },
+  },
+  replacedFor,
+});
+
+export type { CheckoutItemFunctionArgs };
+export { checkoutItem };

package/src/infrastructure/projection/checkoutItem/httpCheckoutItemByIdView.pact.ts

@@ -0,0 +1,62 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { CheckoutItemStatus } from "../../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutItemProjection } from "../../../projection/checkoutItem/checkoutItem";
+import { checkoutItem } from "./checkoutItem.mock";
+import { httpCheckoutItemByIdView } from "./httpCheckoutItemByIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewCheckoutItemById",
+});
+
+const checkoutItemProjection = checkoutItem({ status: CheckoutItemStatus.INITIAL });
+const checkoutItemId = checkoutItemProjection.id;
+
+const checkoutItemResponse: { result: CheckoutItemProjection } = {
+  result: checkoutItemProjection,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutItemResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewCheckoutItemById API", () => {
+  it("returns a valid checkout item for the given id", () => {
+    provider
+      .given("a valid checkout item for the given id")
+      .uponReceiving("checkout item projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-checkout-item-by-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutItemId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+      });
+
+      const response = await httpCheckoutItemByIdView({ httpPost })({
+        checkoutItemId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(checkoutItemResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/checkoutItem/httpCheckoutItemByIdView.test.ts

@@ -0,0 +1,56 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import { CheckoutItemStatus } from "../../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutItemProjection } from "../../../projection/checkoutItem/checkoutItem";
+import { checkoutItem } from "./checkoutItem.mock";
+import { httpCheckoutItemByIdView as sut } from "./httpCheckoutItemByIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpPost: fetchHttpPost({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const checkoutItemId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutResponse: { result: CheckoutItemProjection } = {
+  result: checkoutItem({ status: CheckoutItemStatus.INITIAL }),
+};
+const checkoutItemResponseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(checkoutResponse)),
+} as Response;
+const checkoutItemResponseNotFound: Response = {
+  ok: false,
+  status: 404,
+} as Response;
+const checkoutItemResponseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpCheckoutItemByIdView", () => {
+  it("returns a CheckoutItem projection for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutItemResponseOk));
+
+    const returnedCheckoutItem = await view({ checkoutItemId, signal });
+
+    expect(returnedCheckoutItem).toStrictEqual(checkoutResponse.result);
+  });
+
+  it("returns null for a 404 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutItemResponseNotFound));
+
+    const returnedCheckoutItem = await view({ checkoutItemId, signal });
+
+    expect(returnedCheckoutItem).toBeNull();
+  });
+
+  it("returns null for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutItemResponseError));
+
+    const returnedCheckoutItem = await view({ checkoutItemId, signal });
+
+    expect(returnedCheckoutItem).toBeNull();
+  });
+});

package/src/infrastructure/projection/checkoutItem/httpCheckoutItemByIdView.ts

@@ -0,0 +1,34 @@
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import {
+  CheckoutItemByIdView,
+  ViewCheckoutItemByIdResult,
+} from "../../../projection/checkoutItem/viewCheckoutItemById";
+
+interface HttpCheckoutItemByIdView extends CheckoutItemByIdView {}
+
+interface HttpCheckoutItemByIdViewFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpCheckoutItemByIdViewFunction {
+  (args: HttpCheckoutItemByIdViewFunctionArgs): HttpCheckoutItemByIdView;
+}
+
+interface ViewCheckoutItemByIdResponse {
+  readonly result: ViewCheckoutItemByIdResult;
+}
+
+const httpCheckoutItemByIdView: HttpCheckoutItemByIdViewFunction =
+  ({ httpPost }) =>
+  async ({ checkoutItemId, signal }) =>
+    await httpPost<ViewCheckoutItemByIdResponse, ViewCheckoutItemByIdResult>({
+      endpoint: "/view-checkout-item-by-id",
+      body: { checkoutItemId },
+      signal,
+      result: {
+        error: null,
+        success: (response) => response.result,
+      },
+    });
+
+export { httpCheckoutItemByIdView };