@lookiero/checkout 5.3.0 → 6.0.0-beta.0

package/src/infrastructure/domain/checkoutFeedback/model/httpCheckoutFeedbacks.test.ts

@@ -0,0 +1,34 @@
+import { CheckoutFeedback } from "../../../../domain/checkoutFeedback/model/checkoutFeedback";
+import { CheckoutFeedbackProjection } from "../../../../projection/checkoutFeedback/checkoutFeedback";
+import { getCheckoutFeedback as sutGet, saveCheckoutFeedback as sutSave } from "./httpCheckoutFeedbacks";
+
+const mockHttpCheckoutFeedbacksGive = jest.fn();
+jest.mock("./httpCheckoutFeedbacksGive", () => ({
+  httpCheckoutFeedbacksGive: () => mockHttpCheckoutFeedbacksGive,
+}));
+
+const checkoutId = "63ed5770-7808-45f4-aa22-253a070c0350";
+const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+
+const checkoutFeedbackProjection: CheckoutFeedbackProjection = feedbacks;
+
+const checkoutFeedback: CheckoutFeedback = {
+  aggregateId: "5629461c-29f6-4944-b290-0ef1bdea38b4",
+  checkoutId,
+  feedbacks,
+  domainEvents: [],
+};
+
+const queryBusMock = jest.fn(() => Promise.resolve(checkoutFeedbackProjection));
+
+describe("httpCheckoutFeedbacks", () => {
+  it("throws if trying to get a checkoutFeedback by checkoutId", async () => {
+    expect(async () => await sutGet({ queryBus: queryBusMock })(checkoutId)).rejects.toThrow();
+  });
+
+  it("saves a checkoutFeedback: calls httpCheckoutFeedbacksGive", async () => {
+    await sutSave({ httpPost: jest.fn() })(checkoutFeedback);
+
+    expect(mockHttpCheckoutFeedbacksGive).toHaveBeenCalled();
+  });
+});

package/src/infrastructure/domain/checkoutFeedback/model/httpCheckoutFeedbacks.ts

@@ -0,0 +1,30 @@
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import {
+  CheckoutFeedbacksGetFunction,
+  CheckoutFeedbacksSaveFunction,
+} from "../../../../domain/checkoutFeedback/model/checkoutFeedbacks";
+import { httpCheckoutFeedbacksGive } from "./httpCheckoutFeedbacksGive";
+
+interface HttpCheckoutFeedbacksGetFunctionArgs extends RepositoryGetFunctionArgs {}
+
+interface HttpCheckoutFeedbacksGetFunction extends CheckoutFeedbacksGetFunction<HttpCheckoutFeedbacksGetFunctionArgs> {}
+
+const getCheckoutFeedback: HttpCheckoutFeedbacksGetFunction = () => async () => {
+  throw new Error("There is no equivalent AggregateRoot in the backend");
+};
+
+interface HttpCheckoutFeedbacksSaveFunctionArgs extends RepositorySaveFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpCheckoutFeedbacksSaveFunction
+  extends CheckoutFeedbacksSaveFunction<HttpCheckoutFeedbacksSaveFunctionArgs> {}
+
+const saveCheckoutFeedback: HttpCheckoutFeedbacksSaveFunction =
+  ({ httpPost }) =>
+  async (aggregateRoot) =>
+    await httpCheckoutFeedbacksGive({ httpPost })(aggregateRoot);
+
+export type { HttpCheckoutFeedbacksSaveFunction };
+export { getCheckoutFeedback, saveCheckoutFeedback };

package/src/infrastructure/domain/checkoutFeedback/model/httpCheckoutFeedbacksGive.test.ts

@@ -0,0 +1,42 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import { CheckoutFeedback } from "../../../../domain/checkoutFeedback/model/checkoutFeedback";
+import { checkoutFeedbackGiven } from "../../../../domain/checkoutFeedback/model/checkoutFeedbackGiven";
+import { Feedbacks } from "../../../../domain/checkoutFeedback/model/feedbacks";
+import { httpCheckoutFeedbacksGive as sut } from "./httpCheckoutFeedbacksGive";
+
+const aggregateId = "5629461c-29f6-4944-b290-0ef1bdea38b4";
+const checkoutId = "63ed5770-7808-45f4-aa22-253a070c0350";
+const feedbacks: Feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+
+const checkoutFeedbackWithDomainEvent = (domainEvents: DomainEvent<MessageName>[]): CheckoutFeedback => ({
+  aggregateId,
+  checkoutId,
+  feedbacks,
+  domainEvents,
+});
+
+const httpPostMock = jest.fn(() => Promise.resolve());
+
+afterEach(() => httpPostMock.mockClear());
+
+describe("httpCheckoutFeedbacksGive", () => {
+  it("saves a checkoutFeedback when checkoutFeedbackGiven", async () => {
+    const checkoutFeedback = checkoutFeedbackWithDomainEvent([checkoutFeedbackGiven({ aggregateId, checkoutId })]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutFeedback);
+
+    expect(httpPostMock).toHaveBeenCalledWith({
+      endpoint: "/give-checkout-feedback",
+      body: { checkoutId, feedbacks },
+    });
+  });
+
+  it("does nothing if not checkoutFeedbackGiven", async () => {
+    const checkoutFeedback = checkoutFeedbackWithDomainEvent([]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutFeedback);
+
+    expect(httpPostMock).not.toHaveBeenCalled();
+  });
+});

package/src/infrastructure/domain/checkoutFeedback/model/httpCheckoutFeedbacksGive.ts

@@ -0,0 +1,28 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import {
+  CheckoutFeedbackGiven,
+  CHECKOUT_FEEDBACK_GIVEN,
+} from "../../../../domain/checkoutFeedback/model/checkoutFeedbackGiven";
+import { HttpCheckoutFeedbacksSaveFunction } from "./httpCheckoutFeedbacks";
+
+interface HttpCheckoutFeedbackGiveFunction extends HttpCheckoutFeedbacksSaveFunction {}
+
+const isCheckoutFeedbackGiven = (event: DomainEvent<MessageName>): event is CheckoutFeedbackGiven =>
+  event.name === CHECKOUT_FEEDBACK_GIVEN;
+
+const httpCheckoutFeedbacksGive: HttpCheckoutFeedbackGiveFunction =
+  ({ httpPost }) =>
+  async ({ checkoutId, feedbacks, domainEvents }) => {
+    const checkoutFeedbackGiven = domainEvents.find(isCheckoutFeedbackGiven);
+
+    if (!checkoutFeedbackGiven) {
+      return;
+    }
+
+    await httpPost({
+      endpoint: "/give-checkout-feedback",
+      body: { checkoutId, feedbacks },
+    });
+  };
+
+export { httpCheckoutFeedbacksGive };

package/src/infrastructure/domain/checkoutFeedback/react/useGiveCheckoutFeedback.test.ts

@@ -0,0 +1,81 @@
+import { act, renderHook, waitFor } from "@testing-library/react-native";
+import { mock } from "jest-mock-extended";
+import { bootstrap, CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "@lookiero/sty-psp-logging";
+import { GIVE_CHECKOUT_FEEDBACK } from "../../../../domain/checkoutFeedback/command/giveCheckoutFeedback";
+import { CheckoutFeedback } from "../../../../domain/checkoutFeedback/model/checkoutFeedback";
+import { Feedbacks } from "../../../../domain/checkoutFeedback/model/feedbacks";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+import { useGiveCheckoutFeedback as sut } from "./useGiveCheckoutFeedback";
+
+const mockCreateToastNotification = jest.fn();
+jest.mock("@lookiero/sty-psp-notifications", () => ({
+  ...jest.requireActual("@lookiero/sty-psp-notifications"),
+  useCreateToastNotification: () => [mockCreateToastNotification],
+}));
+
+const aggregateId = "5629461c-29f6-4944-b290-0ef1bdea38b4";
+const checkoutId = "6248e14a-a269-4259-838b-39f493f30769";
+const feedbacks: Feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+
+const checkoutFeedback: CheckoutFeedback = {
+  aggregateId,
+  checkoutId,
+  feedbacks,
+  domainEvents: [],
+};
+
+const logger = mock<Logger>();
+
+const getMock = jest.fn(() => Promise.resolve(checkoutFeedback));
+const get = jest.fn(() => getMock);
+const saveMock = jest.fn();
+const save = jest.fn(() => saveMock);
+const mockFiveCheckoutFeedbackHandler = jest.fn();
+const { Component: Messaging } = bootstrap({ id: MESSAGING_CONTEXT_ID })
+  .command(
+    GIVE_CHECKOUT_FEEDBACK,
+    mockFiveCheckoutFeedbackHandler,
+    {},
+  )(get, save)
+  .build();
+
+describe("useGiveCheckoutFeedback integration hook", () => {
+  it("returns success as the status right after calling 'giveCheckoutFeedback'", async () => {
+    mockFiveCheckoutFeedbackHandler.mockImplementation(() => () => ({ domainEvents: [] }));
+    const { result } = renderHook(() => sut({ checkoutId, logger }), { wrapper: Messaging });
+
+    await act(() => {
+      const [giveCheckoutFeedback] = result.current;
+      giveCheckoutFeedback({ feedbacks });
+    });
+
+    await waitFor(() => {
+      const [, status] = result.current;
+      expect(status).toBe(CommandStatus.SUCCESS);
+    });
+  });
+
+  it("calls logger.captureException and createNotification when 'giveCheckoutFeedback' fails", async () => {
+    const error = new Error("Some error");
+    mockFiveCheckoutFeedbackHandler.mockImplementation(() => () => {
+      throw error;
+    });
+    const { result } = renderHook(() => sut({ checkoutId, logger }), {
+      wrapper: Messaging,
+    });
+
+    await act(() => {
+      const [giveCheckoutFeedback] = result.current;
+      giveCheckoutFeedback({ feedbacks });
+    });
+
+    await waitFor(() => {
+      const [, status] = result.current;
+
+      expect(status).toBe(CommandStatus.ERROR);
+      expect(logger.captureException).toHaveBeenCalledWith(error);
+      expect(mockCreateToastNotification).toHaveBeenCalled();
+    });
+  });
+});

package/src/infrastructure/domain/checkoutFeedback/react/useGiveCheckoutFeedback.ts

@@ -0,0 +1,56 @@
+import { useCallback } from "react";
+import { CommandStatus, useCommand } from "@lookiero/messaging-react";
+import { Logger } from "@lookiero/sty-psp-logging";
+import { NotificationLevel, useCreateToastNotification } from "@lookiero/sty-psp-notifications";
+import { giveCheckoutFeedback as giveCheckoutFeedbackCommand } from "../../../../domain/checkoutFeedback/command/giveCheckoutFeedback";
+import { Feedbacks } from "../../../../domain/checkoutFeedback/model/feedbacks";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+import { I18nMessages } from "../../../ui/i18n/i18n";
+
+interface GiveCheckoutFeedbackFunctionArgs {
+  readonly feedbacks: Feedbacks;
+}
+
+interface GiveCheckoutFeedbackFunction {
+  (args: GiveCheckoutFeedbackFunctionArgs): Promise<void>;
+}
+
+type UseGiveCheckoutFeedback = [giveCheckoutFeedback: GiveCheckoutFeedbackFunction, status: CommandStatus];
+
+interface UseGiveCheckoutFeedbackFunctionArgs {
+  readonly checkoutId: string;
+  readonly logger: Logger;
+}
+
+interface UseGiveCheckoutFeedbackFunction {
+  (args: UseGiveCheckoutFeedbackFunctionArgs): UseGiveCheckoutFeedback;
+}
+
+const useGiveCheckoutFeedback: UseGiveCheckoutFeedbackFunction = ({ checkoutId, logger }) => {
+  const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+  const [createNotification] = useCreateToastNotification({ contextId: MESSAGING_CONTEXT_ID, logger });
+
+  const giveCheckoutFeedback: GiveCheckoutFeedbackFunction = useCallback(
+    async ({ feedbacks }) => {
+      try {
+        await commandBus(
+          giveCheckoutFeedbackCommand({
+            checkoutId,
+            feedbacks,
+          }),
+        );
+      } catch (error) {
+        logger.captureException(error as Error);
+        createNotification({
+          level: NotificationLevel.ERROR,
+          bodyI18nKey: I18nMessages.TOAST_GENERIC_ERROR,
+        });
+      }
+    },
+    [checkoutId, commandBus, createNotification, logger],
+  );
+
+  return [giveCheckoutFeedback, status];
+};
+
+export { useGiveCheckoutFeedback };

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItems.test.ts

@@ -0,0 +1,75 @@
+import { CheckoutItem, CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
+import { Price } from "../../../../domain/checkoutItem/model/price";
+import {
+  CheckoutItemProductVariantProjection,
+  CheckoutItemProjection,
+} from "../../../../projection/checkoutItem/checkoutItem";
+import { PriceProjection } from "../../../../projection/shared/price";
+import { getCheckoutItem as sutGet, saveCheckoutItem as sutSave } from "./httpCheckoutItems";
+
+const mockHttpCheckoutItemsKeep = jest.fn();
+jest.mock("./httpCheckoutItemsKeep", () => ({
+  httpCheckoutItemsKeep: () => mockHttpCheckoutItemsKeep,
+}));
+const mockHttpCheckoutItemsReturn = jest.fn();
+jest.mock("./httpCheckoutItemsReturn", () => ({
+  httpCheckoutItemsReturn: () => mockHttpCheckoutItemsReturn,
+}));
+const mockHttpCheckoutItemsReplace = jest.fn();
+jest.mock("./httpCheckoutItemsReplace", () => ({
+  httpCheckoutItemsReplace: () => mockHttpCheckoutItemsReplace,
+}));
+const mockHttpCheckoutItemsReset = jest.fn();
+jest.mock("./httpCheckoutItemsReset", () => ({
+  httpCheckoutItemsReset: () => mockHttpCheckoutItemsReset,
+}));
+
+const checkoutItemId = "63ed5770-7808-45f4-aa22-253a070c0350";
+const status = CheckoutItemStatus.INITIAL;
+const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+const replacedForId = "3354410c-c465-4c44-8ebf-ad1486aff532";
+
+const checkoutItemProjection: CheckoutItemProjection = {
+  id: checkoutItemId,
+  status,
+  price: {} as PriceProjection,
+  feedbacks,
+  replacedFor: { id: replacedForId } as CheckoutItemProductVariantProjection,
+  productVariant: {} as CheckoutItemProductVariantProjection,
+};
+
+const checkoutItem: CheckoutItem = {
+  aggregateId: checkoutItemId,
+  status,
+  price: {} as Price,
+  feedbacks,
+  replacedForId,
+  domainEvents: [],
+};
+
+const queryBusMock = jest.fn(() => Promise.resolve(checkoutItemProjection));
+
+describe("httpCheckoutItems", () => {
+  it("gets a checkout by aggregateId", async () => {
+    const checkoutItem = await sutGet({ queryBus: queryBusMock })(checkoutItemId);
+
+    expect(checkoutItem).toStrictEqual({
+      aggregateId: checkoutItemId,
+      id: checkoutItemId,
+      status,
+      price: {},
+      feedbacks,
+      replacedForId,
+      domainEvents: [],
+    });
+  });
+
+  it("saves a checkoutItem: calls httpCheckoutItemsKeep, httpCheckoutItemsReturn & httpCheckoutItemsReplace", async () => {
+    await sutSave({ httpPost: jest.fn() })(checkoutItem);
+
+    expect(mockHttpCheckoutItemsKeep).toHaveBeenCalled();
+    expect(mockHttpCheckoutItemsReturn).toHaveBeenCalled();
+    expect(mockHttpCheckoutItemsReplace).toHaveBeenCalled();
+    expect(mockHttpCheckoutItemsReset).toHaveBeenCalled();
+  });
+});

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItems.ts

@@ -0,0 +1,68 @@
+import invariant from "tiny-invariant";
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import { CheckoutItem } from "../../../../domain/checkoutItem/model/checkoutItem";
+import {
+  CheckoutItemsGetFunction,
+  CheckoutItemsSaveFunction,
+} from "../../../../domain/checkoutItem/model/checkoutItems";
+import {
+  viewCheckoutItemById,
+  ViewCheckoutItemById,
+  ViewCheckoutItemByIdResult,
+} from "../../../../projection/checkoutItem/viewCheckoutItemById";
+import { httpCheckoutItemsKeep } from "./httpCheckoutItemsKeep";
+import { httpCheckoutItemsReplace } from "./httpCheckoutItemsReplace";
+import { httpCheckoutItemsReset } from "./httpCheckoutItemsReset";
+import { httpCheckoutItemsReturn } from "./httpCheckoutItemsReturn";
+
+interface ToDomainFunction {
+  (checkout: ViewCheckoutItemByIdResult): CheckoutItem | never;
+}
+
+const toDomain: ToDomainFunction = (checkoutItem) => {
+  invariant(checkoutItem, "No checkoutItem found!");
+
+  return {
+    id: checkoutItem.id,
+    status: checkoutItem.status,
+    price: checkoutItem.price,
+    feedbacks: checkoutItem.feedbacks,
+    replacedForId: checkoutItem.replacedFor?.id,
+    aggregateId: checkoutItem.id,
+    domainEvents: [],
+  };
+};
+
+interface HttpCheckoutItemsGetFunctionArgs extends RepositoryGetFunctionArgs {}
+
+interface HttpCheckoutItemsGetFunction extends CheckoutItemsGetFunction<HttpCheckoutItemsGetFunctionArgs> {}
+
+const getCheckoutItem: HttpCheckoutItemsGetFunction =
+  ({ queryBus }) =>
+  async (aggregateId) =>
+    toDomain(
+      await queryBus<ViewCheckoutItemById, ViewCheckoutItemByIdResult>(
+        viewCheckoutItemById({ checkoutItemId: aggregateId }),
+      ),
+    );
+
+interface HttpCheckoutItemsSaveFunctionArgs extends RepositorySaveFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpCheckoutItemsSaveFunction extends CheckoutItemsSaveFunction<HttpCheckoutItemsSaveFunctionArgs> {}
+
+const saveCheckoutItem: HttpCheckoutItemsSaveFunction =
+  ({ httpPost }) =>
+  async (aggregateRoot) => {
+    await Promise.all([
+      httpCheckoutItemsKeep({ httpPost })(aggregateRoot),
+      httpCheckoutItemsReturn({ httpPost })(aggregateRoot),
+      httpCheckoutItemsReplace({ httpPost })(aggregateRoot),
+      httpCheckoutItemsReset({ httpPost })(aggregateRoot),
+    ]);
+  };
+
+export type { HttpCheckoutItemsSaveFunction };
+export { getCheckoutItem, saveCheckoutItem };

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItemsKeep.test.ts

@@ -0,0 +1,45 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import { CheckoutItem, CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
+import { checkoutItemKept } from "../../../../domain/checkoutItem/model/checkoutItemKept";
+import { Price } from "../../../../domain/checkoutItem/model/price";
+import { httpCheckoutItemsKeep as sut } from "./httpCheckoutItemsKeep";
+
+const checkoutItemId = "63ed5770-7808-45f4-aa22-253a070c0350";
+const status = CheckoutItemStatus.INITIAL;
+const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+const replacedForId = "134e12e3-b677-42eb-9d9d-3cc3bc215e93";
+
+const checkoutItemWithDomainEvent = (domainEvents: DomainEvent<MessageName>[]): CheckoutItem => ({
+  aggregateId: checkoutItemId,
+  status,
+  price: {} as Price,
+  feedbacks,
+  replacedForId,
+  domainEvents,
+});
+
+const httpPostMock = jest.fn(() => Promise.resolve());
+
+afterEach(() => httpPostMock.mockClear());
+
+describe("httpCheckoutItemsKeep", () => {
+  it("saves a checkoutItem when checkoutItemKept", async () => {
+    const checkoutItem = checkoutItemWithDomainEvent([checkoutItemKept({ aggregateId: checkoutItemId })]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutItem);
+
+    expect(httpPostMock).toHaveBeenCalledWith({
+      endpoint: "/keep-checkout-item",
+      body: { checkoutItemId },
+    });
+  });
+
+  it("does nothing if not checkoutItemKept", async () => {
+    const checkoutItem = checkoutItemWithDomainEvent([]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutItem);
+
+    expect(httpPostMock).not.toHaveBeenCalled();
+  });
+});

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItemsKeep.ts

@@ -0,0 +1,25 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { CheckoutItemKept, CHECKOUT_ITEM_KEPT } from "../../../../domain/checkoutItem/model/checkoutItemKept";
+import { HttpCheckoutItemsSaveFunction } from "./httpCheckoutItems";
+
+interface HttpCheckoutItemsKeepFunction extends HttpCheckoutItemsSaveFunction {}
+
+const isCheckoutItemKept = (event: DomainEvent<MessageName>): event is CheckoutItemKept =>
+  event.name === CHECKOUT_ITEM_KEPT;
+
+const httpCheckoutItemsKeep: HttpCheckoutItemsKeepFunction =
+  ({ httpPost }) =>
+  async ({ aggregateId, domainEvents }) => {
+    const checkoutItemKept = domainEvents.find(isCheckoutItemKept);
+
+    if (!checkoutItemKept) {
+      return;
+    }
+
+    await httpPost({
+      endpoint: "/keep-checkout-item",
+      body: { checkoutItemId: aggregateId },
+    });
+  };
+
+export { httpCheckoutItemsKeep };

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItemsReplace.test.ts

@@ -0,0 +1,45 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import { CheckoutItem, CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
+import { checkoutItemReplaced } from "../../../../domain/checkoutItem/model/checkoutItemReplaced";
+import { Price } from "../../../../domain/checkoutItem/model/price";
+import { httpCheckoutItemsReplace as sut } from "./httpCheckoutItemsReplace";
+
+const checkoutItemId = "63ed5770-7808-45f4-aa22-253a070c0350";
+const status = CheckoutItemStatus.INITIAL;
+const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+const replacedForId = "134e12e3-b677-42eb-9d9d-3cc3bc215e93";
+
+const checkoutItemWithDomainEvent = (domainEvents: DomainEvent<MessageName>[]): CheckoutItem => ({
+  aggregateId: checkoutItemId,
+  status,
+  price: {} as Price,
+  feedbacks,
+  replacedForId,
+  domainEvents,
+});
+
+const httpPostMock = jest.fn(() => Promise.resolve());
+
+afterEach(() => httpPostMock.mockClear());
+
+describe("httpCheckoutItemsReplace", () => {
+  it("saves a checkoutItem when checkoutItemReplaced", async () => {
+    const checkoutItem = checkoutItemWithDomainEvent([checkoutItemReplaced({ aggregateId: checkoutItemId })]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutItem);
+
+    expect(httpPostMock).toHaveBeenCalledWith({
+      endpoint: "/replace-checkout-item",
+      body: { checkoutItemId, replacedFor: replacedForId },
+    });
+  });
+
+  it("does nothing if not checkoutItemReplaced", async () => {
+    const checkoutItem = checkoutItemWithDomainEvent([]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutItem);
+
+    expect(httpPostMock).not.toHaveBeenCalled();
+  });
+});

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItemsReplace.ts

@@ -0,0 +1,28 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import {
+  CheckoutItemReplaced,
+  CHECKOUT_ITEM_REPLACED,
+} from "../../../../domain/checkoutItem/model/checkoutItemReplaced";
+import { HttpCheckoutItemsSaveFunction } from "./httpCheckoutItems";
+
+interface HttpCheckoutItemsReplaceFunction extends HttpCheckoutItemsSaveFunction {}
+
+const isCheckoutItemReplaced = (event: DomainEvent<MessageName>): event is CheckoutItemReplaced =>
+  event.name === CHECKOUT_ITEM_REPLACED;
+
+const httpCheckoutItemsReplace: HttpCheckoutItemsReplaceFunction =
+  ({ httpPost }) =>
+  async ({ aggregateId, replacedForId, domainEvents }) => {
+    const checkoutItemReplaced = domainEvents.find(isCheckoutItemReplaced);
+
+    if (!checkoutItemReplaced) {
+      return;
+    }
+
+    await httpPost({
+      endpoint: "/replace-checkout-item",
+      body: { checkoutItemId: aggregateId, replacedFor: replacedForId },
+    });
+  };
+
+export { httpCheckoutItemsReplace };

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItemsReset.test.ts

@@ -0,0 +1,45 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import { CheckoutItem, CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
+import { checkoutItemReset } from "../../../../domain/checkoutItem/model/checkoutItemReset";
+import { Price } from "../../../../domain/checkoutItem/model/price";
+import { httpCheckoutItemsReset as sut } from "./httpCheckoutItemsReset";
+
+const checkoutItemId = "63ed5770-7808-45f4-aa22-253a070c0350";
+const status = CheckoutItemStatus.INITIAL;
+const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+const replacedForId = "134e12e3-b677-42eb-9d9d-3cc3bc215e93";
+
+const checkoutItemWithDomainEvent = (domainEvents: DomainEvent<MessageName>[]): CheckoutItem => ({
+  aggregateId: checkoutItemId,
+  status,
+  price: {} as Price,
+  feedbacks,
+  replacedForId,
+  domainEvents,
+});
+
+const httpPostMock = jest.fn(() => Promise.resolve());
+
+afterEach(() => httpPostMock.mockClear());
+
+describe("httpCheckoutItemsReset", () => {
+  it("saves a checkoutItem when checkoutItemReset", async () => {
+    const checkoutItem = checkoutItemWithDomainEvent([checkoutItemReset({ aggregateId: checkoutItemId })]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutItem);
+
+    expect(httpPostMock).toHaveBeenCalledWith({
+      endpoint: "/reset-checkout-item",
+      body: { checkoutItemId },
+    });
+  });
+
+  it("does nothing if not checkoutItemReset", async () => {
+    const checkoutItem = checkoutItemWithDomainEvent([]);
+
+    await sut({ httpPost: httpPostMock as HttpPostFunction })(checkoutItem);
+
+    expect(httpPostMock).not.toHaveBeenCalled();
+  });
+});

package/src/infrastructure/domain/checkoutItem/model/httpCheckoutItemsReset.ts

@@ -0,0 +1,25 @@
+import { DomainEvent, MessageName } from "@lookiero/messaging";
+import { CheckoutItemReset, CHECKOUT_ITEM_RESET } from "../../../../domain/checkoutItem/model/checkoutItemReset";
+import { HttpCheckoutItemsSaveFunction } from "./httpCheckoutItems";
+
+interface HttpCheckoutItemsResetFunction extends HttpCheckoutItemsSaveFunction {}
+
+const isCheckoutItemReset = (event: DomainEvent<MessageName>): event is CheckoutItemReset =>
+  event.name === CHECKOUT_ITEM_RESET;
+
+const httpCheckoutItemsReset: HttpCheckoutItemsResetFunction =
+  ({ httpPost }) =>
+  async ({ aggregateId, domainEvents }) => {
+    const checkoutItemReset = domainEvents.find(isCheckoutItemReset);
+
+    if (!checkoutItemReset) {
+      return;
+    }
+
+    await httpPost({
+      endpoint: "/reset-checkout-item",
+      body: { checkoutItemId: aggregateId },
+    });
+  };
+
+export { httpCheckoutItemsReset };