@lookiero/checkout 9.14.0 → 10.0.0-beta.0

package/dist/src/infrastructure/projection/checkout/httpIsSizeChangeEnabledByCheckoutIdView.pact.js

@@ -0,0 +1,51 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { httpIsSizeChangeEnabledByCheckoutIdView } from "./httpIsSizeChangeEnabledByCheckoutIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewIsSizeChangeEnabledByCheckoutId",
+});
+const checkoutId = "fab61a4d-c94d-4e33-b098-1945294a5f75";
+const isSizeChangeEnabledResponse = true;
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(isSizeChangeEnabledResponse);
+describe("STY-BOX_CHECKOUT-BACK_ViewIsSizeChangeEnabledByCheckoutId API", () => {
+  it("returns is size-change enabled for the given checkout id", () => {
+    provider
+      .given("is size-change enabled for the given checkout id")
+      .uponReceiving("is size-change enabled")
+      .withRequest({
+        method: "GET",
+        path: `/api/is-size-change-enabled-by-checkout-id/${checkoutId}`,
+        headers: DEFAULT_REQUEST_HEADERS,
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+    return provider.executeTest(async (mockserver) => {
+      const httpGet = fetchHttpGet({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpIsSizeChangeEnabledByCheckoutIdView({ httpGet })({
+        checkoutId,
+        signal: undefined,
+      });
+      expect(response).toStrictEqual(isSizeChangeEnabledResponse);
+    });
+  });
+});

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

@@ -0,0 +1,13 @@
+import { UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { IsCheckoutAccessibleByCustomerIdProjection } from "../../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+
+interface UseViewIsCheckoutAccessibleByCustomerIdFunctionArgs {
+  readonly customerId: string | undefined;
+}
+interface UseViewIsCheckoutAccessibleByCustomerIdFunction {
+  (
+    args: UseViewIsCheckoutAccessibleByCustomerIdFunctionArgs,
+  ): UseQueryFunctionResult<IsCheckoutAccessibleByCustomerIdProjection>;
+}
+declare const useViewIsCheckoutAccessibleByCustomerId: UseViewIsCheckoutAccessibleByCustomerIdFunction;
+export { useViewIsCheckoutAccessibleByCustomerId };

package/dist/src/infrastructure/projection/checkout/react/useViewIsCheckoutAccessibleByCustomerId.js

@@ -0,0 +1,19 @@
+import { useQuery } from "@lookiero/messaging-react";
+import { isCheckoutFeedbackGiven } from "../../../../domain/checkoutFeedback/model/checkoutFeedbackGiven";
+import { viewIsCheckoutAccessibleByCustomerId } from "../../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+
+const useViewIsCheckoutAccessibleByCustomerId = ({ 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/dist/src/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.pact.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.pact.js

@@ -0,0 +1,56 @@
+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 { 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,
+};
+// 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),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpCheckoutBookingByIdView({ httpPost })({
+        checkoutBookingId,
+        signal: undefined,
+      });
+      expect(response).toStrictEqual(checkoutBookingResponse.result);
+    });
+  });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/src/infrastructure/projection/checkoutItem/httpCheckoutItemByIdView.pact.js

@@ -0,0 +1,57 @@
+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 { 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,
+};
+// 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),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpCheckoutItemByIdView({ httpPost })({
+        checkoutItemId,
+        signal: undefined,
+      });
+      expect(response).toStrictEqual(checkoutItemResponse.result);
+    });
+  });
+});

package/dist/src/infrastructure/projection/checkoutQuestion/httpCheckoutQuestionsByCheckoutIdView.pact.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/infrastructure/projection/checkoutQuestion/httpCheckoutQuestionsByCheckoutIdView.pact.js

@@ -0,0 +1,55 @@
+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 { checkoutQuestions } from "./checkoutQuestions.mock";
+import { httpCheckoutQuestionsByCheckoutIdView } from "./httpCheckoutQuestionsByCheckoutIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ListCheckoutQuestionsByCheckoutId",
+});
+const checkoutId = "52440ae5-7a4c-498b-8b35-08ecfde15776";
+const checkoutQuestionsResponse = {
+  result: checkoutQuestions,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutQuestionsResponse);
+describe("STY-BOX_CHECKOUT-BACK_ListCheckoutQuestionsByCheckoutId API", () => {
+  it("returns a valid checkout questions for the given checkout id", () => {
+    provider
+      .given("a valid checkout questions for the given checkout id")
+      .uponReceiving("checkout questions projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/list-checkout-questions-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .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),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpCheckoutQuestionsByCheckoutIdView({ httpPost })({
+        checkoutId,
+        signal: undefined,
+      });
+      expect(response).toStrictEqual(checkoutQuestionsResponse.result);
+    });
+  });
+});

package/dist/src/infrastructure/projection/payment/httpPaymentFlowPayloadByCheckoutIdView.pact.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/infrastructure/projection/payment/httpPaymentFlowPayloadByCheckoutIdView.pact.js

@@ -0,0 +1,120 @@
+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 { httpPaymentFlowPayloadByCheckoutIdView } from "./httpPaymentFlowPayloadByCheckoutIdView";
+import {
+  paymentFlowPayloadForKeptItems,
+  paymentFlowPayloadForReturnedItems,
+  paymentFlowPayloadForReplacedItems,
+} from "./paymentFlowPayload.mock";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewPaymentFlowPayloadByCheckoutId",
+});
+const checkoutId = "e2490de5-5bd3-43d5-b7c4-526e33f71304";
+const paymentFlowPayloadForKeptItemsResponse = {
+  result: paymentFlowPayloadForKeptItems,
+};
+const paymentFlowPayloadForReturnedItemsResponse = {
+  result: paymentFlowPayloadForReturnedItems,
+};
+const paymentFlowPayloadForReplacedItemsResponse = {
+  result: paymentFlowPayloadForReplacedItems,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY_FOR_KEPT_ITEMS = MatchersV3.like(paymentFlowPayloadForKeptItemsResponse);
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY_FOR_RETURNED_ITEMS = MatchersV3.like(paymentFlowPayloadForReturnedItemsResponse);
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY_FOR_REPLACED_ITEMS = MatchersV3.like(paymentFlowPayloadForReplacedItemsResponse);
+describe("STY-BOX_CHECKOUT-BACK_ViewPaymentFlowPayloadByCheckoutId API", () => {
+  it("returns a valid payment-flow payload for the given checkout id [KEPT items] ", () => {
+    provider
+      .given("a valid payment-flow payload for the given checkout id [KEPT items] ")
+      .uponReceiving("payment-flow payload projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-payment-flow-payload-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY_FOR_KEPT_ITEMS,
+      });
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpPaymentFlowPayloadByCheckoutIdView({ httpPost })({ checkoutId, signal: undefined });
+      expect(response).toStrictEqual(paymentFlowPayloadForKeptItemsResponse.result);
+    });
+  });
+  it("returns a valid payment-flow payload for the given checkout id [RETURNED items] ", () => {
+    provider
+      .given("a valid payment-flow payload for the given checkout id [RETURNED items] ")
+      .uponReceiving("payment-flow payload projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-payment-flow-payload-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY_FOR_RETURNED_ITEMS,
+      });
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpPaymentFlowPayloadByCheckoutIdView({ httpPost })({ checkoutId, signal: undefined });
+      expect(response).toStrictEqual(paymentFlowPayloadForReturnedItemsResponse.result);
+    });
+  });
+  it("returns a valid payment-flow payload for the given checkout id [REPLACED items] ", () => {
+    provider
+      .given("a valid payment-flow payload for the given checkout id [REPLACED items] ")
+      .uponReceiving("payment-flow payload projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-payment-flow-payload-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY_FOR_REPLACED_ITEMS,
+      });
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpPaymentFlowPayloadByCheckoutIdView({ httpPost })({ checkoutId, signal: undefined });
+      expect(response).toStrictEqual(paymentFlowPayloadForReplacedItemsResponse.result);
+    });
+  });
+});

package/dist/src/infrastructure/projection/pricing/httpPricingByCheckoutIdView.pact.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/infrastructure/projection/pricing/httpPricingByCheckoutIdView.pact.js

@@ -0,0 +1,55 @@
+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 { httpPricingByCheckoutIdView } from "./httpPricingByCheckoutIdView";
+import { pricing } from "./pricing.mock";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewPricingByCheckoutId",
+});
+const checkoutId = "6f720954-8039-4bed-9596-34fc5a02131b";
+const pricingResponse = {
+  result: pricing(),
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(pricingResponse);
+describe("STY-BOX_CHECKOUT-BACK_ViewPricingByCheckoutId API", () => {
+  it("returns a valid pricing for the given checkout", () => {
+    provider
+      .given("a valid pricing for the given checkout")
+      .uponReceiving("pricing projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-pricing-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .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),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpPricingByCheckoutIdView({ httpPost })({
+        checkoutId,
+        signal: undefined,
+      });
+      expect(response).toStrictEqual(pricingResponse.result);
+    });
+  });
+});

package/dist/src/infrastructure/projection/pricing/react/useViewPricingByCheckoutId.d.ts

@@ -4,7 +4,7 @@ interface QueryOptions {
     readonly refetchOnMount?: boolean | "always";
 }
 interface UseViewPricingByCheckoutIdFunctionArgs {
-    readonly checkoutId: string;
+    readonly checkoutId: string | undefined;
     readonly queryOptions?: QueryOptions;
 }
 interface UseViewPricingByCheckoutIdFunction {

package/dist/src/infrastructure/projection/pricing/react/useViewPricingByCheckoutId.js

@@ -13,7 +13,7 @@ const DEFAULT_QUERY_OPTIONS = {
     refetchOnMount: "always",
 };
 const useViewPricingByCheckoutId = ({ checkoutId, queryOptions = DEFAULT_QUERY_OPTIONS, }) => useQuery({
-    query: viewPricingByCheckoutId({ checkoutId }),
+    query: viewPricingByCheckoutId({ checkoutId: checkoutId }),
     contextId: MESSAGING_CONTEXT_ID,
     invalidation: shouldInvalidate,
     options: {
@@ -21,6 +21,7 @@ const useViewPricingByCheckoutId = ({ checkoutId, queryOptions = DEFAULT_QUERY_O
         staleTime: Infinity,
         retry: false,
         refetchOnWindowFocus: false,
+        enabled: Boolean(checkoutId),
     },
 });
 export { useViewPricingByCheckoutId };

package/dist/src/infrastructure/projection/returnQuestion/httpReturnQuestionsByCheckoutItemIdView.pact.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/infrastructure/projection/returnQuestion/httpReturnQuestionsByCheckoutItemIdView.pact.js

@@ -0,0 +1,55 @@
+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 { httpReturnQuestionsByCheckoutItemIdView } from "./httpReturnQuestionsByCheckoutItemIdView";
+import { returnQuestions } from "./returnQuestions.mock";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ListReturnQuestionsByCheckoutItemId",
+});
+const checkoutItemId = "52440ae5-7a4c-498b-8b35-08ecfde15776";
+const returnQuestionsResponse = {
+  result: returnQuestions,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(returnQuestionsResponse);
+describe("STY-BOX_CHECKOUT-BACK_ListReturnQuestionsByCheckoutItemId API", () => {
+  it("returns a valid return questions for the given checkout item id", () => {
+    provider
+      .given("a valid return questions for the given checkout item id")
+      .uponReceiving("return questions projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/list-return-questions-by-checkout-item-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),
+        device: "web",
+        version: "1.0.0",
+      });
+      const response = await httpReturnQuestionsByCheckoutItemIdView({ httpPost })({
+        checkoutItemId,
+        signal: undefined,
+      });
+      expect(response).toStrictEqual(returnQuestionsResponse.result);
+    });
+  });
+});

package/dist/src/infrastructure/tracking/tracking.d.ts

@@ -2,7 +2,7 @@ import { BaseTrackingEvent, TrackingEventCategory } from "@lookiero/sty-psp-trac
 import { CheckoutItemStatus } from "../../domain/checkoutItem/model/checkoutItem";
 import { Currency } from "../../domain/checkoutItem/model/currency";
 import { MediaPerspective } from "../../projection/checkoutItem/checkoutItem";
-import { Subscription } from "../../projection/subscription/subscription";
+import { SubscriptionProjection } from "../../projection/subscription/subscription";
 declare const PROJECT = "checkout";
 declare enum TrackingPage {
     ITEM = "item",
@@ -96,7 +96,7 @@ interface CheckoutTrackingEvent extends CheckoutBaseTrackingEvent<TrackingEventN
             readonly actionField: {
                 readonly items: number;
                 readonly currencyCode: Currency;
-                readonly subscription: Subscription;
+                readonly subscription: SubscriptionProjection;
                 readonly coupon: string | null;
                 readonly orderId: number;
                 readonly value: number;

package/dist/src/infrastructure/tracking/useTrackCheckout.d.ts

@@ -1,26 +1,19 @@
 import { Country } from "@lookiero/sty-psp-locale";
 import { Segment } from "@lookiero/sty-psp-segment";
-import { Currency } from "../../domain/checkoutItem/model/currency";
-import { Subscription } from "../../projection/subscription/subscription";
-import { TrackingPage } from "./tracking";
-interface TrackCheckoutFunctionArgs {
-    readonly userId: string;
-    readonly totalReplacedFor: number;
-    readonly isFirstOrder: boolean;
-    readonly totalCheckoutItemsKept: number;
-    readonly currencyCode: Currency;
-    readonly subscription: Subscription;
-    readonly coupon: string | null;
-    readonly orderNumber: number;
-    readonly pendingToPay: number;
-}
+import { CheckoutProjection } from "../../projection/checkout/checkout";
+import { OrderProjection } from "../../projection/order/order";
+import { PricingProjection } from "../../projection/pricing/pricing";
+import { SubscriptionProjection } from "../../projection/subscription/subscription";
 interface TrackCheckoutFunction {
-    (args: TrackCheckoutFunctionArgs): void;
+    (): void;
 }
 interface UseTrackCheckoutFunctionArgs {
-    readonly page: TrackingPage;
+    readonly order: OrderProjection;
+    readonly checkout: CheckoutProjection | undefined;
+    readonly pricing: PricingProjection | undefined;
+    readonly subscription: SubscriptionProjection;
+    readonly userId: string;
     readonly country: Country;
-    readonly checkoutId: string | undefined;
     readonly segment: Segment;
 }
 interface UseTrackCheckoutFunction {

package/dist/src/infrastructure/tracking/useTrackCheckout.js

@@ -1,38 +1,53 @@
 import { useCallback } from "react";
+import invariant from "tiny-invariant";
 import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
-import { PROJECT } from "./tracking";
+import { CheckoutItemStatus } from "../../domain/checkoutItem/model/checkoutItem";
+import { PROJECT, TrackingPage } from "./tracking";
 import { TrackingEventName, TrackingEventCategory } from "./tracking";
-const useTrackCheckout = ({ page, country, checkoutId, segment }) => {
+const useTrackCheckout = ({ order, checkout, pricing, subscription, segment, country, userId, }) => {
     const emitUserEvent = useEmitUserEvent();
-    const trackCheckout = useCallback(({ coupon, currencyCode, isFirstOrder, orderNumber, pendingToPay, subscription, totalCheckoutItemsKept, totalReplacedFor, userId, }) => {
-        if (!checkoutId) {
-            return;
-        }
+    const { coupon, isFirstOrder, orderNumber } = order;
+    const trackCheckout = useCallback(() => {
+        invariant(checkout, "Checkout must be defined to track checkout");
+        const checkoutItemsKept = checkout.items.filter((checkoutItem) => checkoutItem.status === CheckoutItemStatus.KEPT || checkoutItem.status === CheckoutItemStatus.REPLACED);
+        const totalReplacedFor = checkoutItemsKept?.filter(({ replacedFor }) => Boolean(replacedFor)).length || 0;
         const checkoutTrackingEvent = {
             event: TrackingEventName.CHECKOUT,
             eventCategory: TrackingEventCategory.ECOMMERCE,
-            section: `${PROJECT}_${page}`,
+            section: `${PROJECT}_${TrackingPage.CHECKOUT}`,
             store: country,
             segment,
-            checkoutId,
+            checkoutId: checkout.id,
             userId,
             sizeChanges: totalReplacedFor,
             isFirstOrder,
             ecommerce: {
                 checkout: {
                     actionField: {
-                        items: totalCheckoutItemsKept,
-                        currencyCode,
+                        items: checkoutItemsKept.length || 0,
+                        currencyCode: pricing?.pendingToPay.currency,
                         subscription,
                         coupon,
                         orderId: orderNumber,
-                        value: pendingToPay,
+                        value: pricing?.pendingToPay.amount / 100,
                     },
                 },
             },
         };
         emitUserEvent(checkoutTrackingEvent);
-    }, [checkoutId, country, emitUserEvent, page, segment]);
+    }, [
+        checkout,
+        country,
+        coupon,
+        emitUserEvent,
+        isFirstOrder,
+        orderNumber,
+        pricing?.pendingToPay.amount,
+        pricing?.pendingToPay.currency,
+        segment,
+        subscription,
+        userId,
+    ]);
     return trackCheckout;
 };
 export { useTrackCheckout };