@lookiero/checkout 5.3.0 → 6.0.0-beta.1

package/src/domain/checkoutBooking/event/createToastNotificationWhenCheckoutBookingExpired.ts

@@ -0,0 +1,23 @@
+import { ProcessManagerFunction } from "@lookiero/messaging";
+import { NotificationLevel, createToastNotification } from "@lookiero/sty-psp-notifications";
+import { I18nMessages } from "../../../infrastructure/ui/i18n/i18n";
+import { CheckoutBookingExpired } from "../model/checkoutBookingExpired";
+
+const CHECKOUT_BOOKING_EXPIRED_NOTIFICATION_ID = "d423934e-2499-46ab-8cfb-39e1e398237e";
+
+interface CreateToastNotificationWhenCheckoutBookingExpiredFunction
+  extends ProcessManagerFunction<CheckoutBookingExpired> {}
+
+const createToastNotificationWhenCheckoutBookingExpired: CreateToastNotificationWhenCheckoutBookingExpiredFunction =
+  ({ commandBus }) =>
+  async () => {
+    await commandBus(
+      createToastNotification({
+        aggregateId: CHECKOUT_BOOKING_EXPIRED_NOTIFICATION_ID,
+        level: NotificationLevel.ERROR,
+        bodyI18nKey: I18nMessages.CHECKOUT_TOAST_BOOKING_EXPIRED,
+      }),
+    );
+  };
+
+export { createToastNotificationWhenCheckoutBookingExpired, CHECKOUT_BOOKING_EXPIRED_NOTIFICATION_ID };

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

@@ -0,0 +1,71 @@
+import { mock } from "jest-mock-extended";
+import { QueryBus } from "@lookiero/messaging";
+import { blockCheckoutBooking } from "../command/blockCheckoutBooking";
+import { bookCheckoutBookingForCheckoutItem } from "../command/bookCheckoutBookingForCheckoutItem";
+import {
+  bookCheckoutBookingForCheckoutItemHandler as sutBook,
+  blockCheckoutBookingHandler as sutBlock,
+  CheckoutBooking,
+} from "./checkoutBooking";
+import { CHECKOUT_BOOKING_BLOCKED } from "./checkoutBookingBlocked";
+import { CHECKOUT_BOOKING_BOOKED } from "./checkoutBookingBooked";
+import { CHECKOUT_BOOKING_EXPIRED } from "./checkoutBookingExpired";
+
+const checkoutItemId = "b4563f59-9786-4544-aafe-405d9d21a6fc";
+const checkoutBooking: CheckoutBooking = {
+  aggregateId: "ca331fba-68a6-4ed4-973f-9afc2e27569d",
+  checkoutItemIds: [checkoutItemId],
+  isExpired: false,
+  domainEvents: [],
+};
+
+describe("checkoutBooking", () => {
+  const queryBus = mock<QueryBus>();
+
+  test("books", async () => {
+    const command = bookCheckoutBookingForCheckoutItem({
+      aggregateId: checkoutBooking.aggregateId,
+      checkoutItemId,
+    });
+
+    const aggregateRoot = await sutBook({ queryBus })({ aggregateRoot: checkoutBooking, command });
+
+    expect(aggregateRoot.aggregateId).toBe(checkoutBooking.aggregateId);
+    expect(aggregateRoot.checkoutItemIds).toBe(checkoutBooking.checkoutItemIds);
+    expect(aggregateRoot.isExpired).toBe(checkoutBooking.isExpired);
+    expect(aggregateRoot.domainEvents[0].name).toBe(CHECKOUT_BOOKING_BOOKED);
+  });
+
+  test("blocks", async () => {
+    const command = blockCheckoutBooking({
+      aggregateId: checkoutBooking.aggregateId,
+    });
+
+    const aggregateRoot = await sutBlock({ queryBus })({ aggregateRoot: checkoutBooking, command });
+
+    expect(aggregateRoot.aggregateId).toBe(checkoutBooking.aggregateId);
+    expect(aggregateRoot.checkoutItemIds).toBe(checkoutBooking.checkoutItemIds);
+    expect(aggregateRoot.isExpired).toBe(checkoutBooking.isExpired);
+    expect(aggregateRoot.domainEvents[0].name).toBe(CHECKOUT_BOOKING_BLOCKED);
+  });
+
+  test("trying to block a expired checkout ", async () => {
+    const checkoutBooking: CheckoutBooking = {
+      aggregateId: "ca331fba-68a6-4ed4-973f-9afc2e27569d",
+      checkoutItemIds: [checkoutItemId],
+      isExpired: true,
+      domainEvents: [],
+    };
+
+    const command = blockCheckoutBooking({
+      aggregateId: checkoutBooking.aggregateId,
+    });
+
+    const aggregateRoot = await sutBlock({ queryBus })({ aggregateRoot: checkoutBooking, command });
+
+    expect(aggregateRoot.aggregateId).toBe(checkoutBooking.aggregateId);
+    expect(aggregateRoot.checkoutItemIds).toBe(checkoutBooking.checkoutItemIds);
+    expect(aggregateRoot.isExpired).toBe(checkoutBooking.isExpired);
+    expect(aggregateRoot.domainEvents[0].name).toBe(CHECKOUT_BOOKING_EXPIRED);
+  });
+});

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

@@ -0,0 +1,46 @@
+import { AggregateRoot, CommandHandlerFunction } from "@lookiero/messaging";
+import { BlockCheckoutBooking } from "../command/blockCheckoutBooking";
+import { BookCheckoutBookingForCheckoutItem } from "../command/bookCheckoutBookingForCheckoutItem";
+import { checkoutBookingBlocked } from "./checkoutBookingBlocked";
+import { checkoutBookingBooked } from "./checkoutBookingBooked";
+import { checkoutBookingExpired } from "./checkoutBookingExpired";
+
+interface CheckoutBooking extends AggregateRoot {
+  readonly checkoutItemIds: string[];
+  readonly isExpired: boolean;
+}
+
+const bookCheckoutBookingForCheckoutItemHandler: CommandHandlerFunction<
+  BookCheckoutBookingForCheckoutItem,
+  CheckoutBooking
+> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId, checkoutItemId } = command;
+
+    return {
+      ...aggregateRoot,
+      domainEvents: [checkoutBookingBooked({ aggregateId, checkoutItemId })],
+    };
+  };
+
+const blockCheckoutBookingHandler: CommandHandlerFunction<BlockCheckoutBooking, CheckoutBooking> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId } = command;
+
+    if (aggregateRoot.isExpired) {
+      return {
+        ...aggregateRoot,
+        domainEvents: [checkoutBookingExpired({ aggregateId })],
+      };
+    }
+
+    return {
+      ...aggregateRoot,
+      domainEvents: [checkoutBookingBlocked({ aggregateId })],
+    };
+  };
+
+export type { CheckoutBooking };
+export { bookCheckoutBookingForCheckoutItemHandler, blockCheckoutBookingHandler };

package/src/domain/checkoutBooking/model/checkoutBookingBlocked.test.ts

@@ -0,0 +1,12 @@
+import { checkoutBookingBlocked as sut, CHECKOUT_BOOKING_BLOCKED } from "./checkoutBookingBlocked";
+
+describe("checkoutBookingBlocked", () => {
+  it("returns an CheckoutBookingBlocked domain event", () => {
+    const aggregateId = "d99810a4-a453-45b9-acc9-71896651e641";
+
+    const domainEvent = sut({ aggregateId });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.name).toBe(CHECKOUT_BOOKING_BLOCKED);
+  });
+});

package/src/domain/checkoutBooking/model/checkoutBookingBlocked.ts

@@ -0,0 +1,19 @@
+import { domainEvent, DomainEvent } from "@lookiero/messaging";
+
+const CHECKOUT_BOOKING_BLOCKED = "checkout_booking_blocked";
+
+interface CheckoutBookingBlokedPaylcoad {
+  readonly aggregateId: string;
+}
+
+interface CheckoutBookingBlocked extends DomainEvent<typeof CHECKOUT_BOOKING_BLOCKED>, CheckoutBookingBlokedPaylcoad {}
+
+interface CheckoutBookingBlokedFunctcion {
+  (payload: CheckoutBookingBlokedPaylcoad): CheckoutBookingBlocked;
+}
+
+const checkoutBookingBlocked: CheckoutBookingBlokedFunctcion = ({ aggregateId }) =>
+  domainEvent({ aggregateId, name: CHECKOUT_BOOKING_BLOCKED });
+
+export type { CheckoutBookingBlocked };
+export { CHECKOUT_BOOKING_BLOCKED, checkoutBookingBlocked };

package/src/domain/checkoutBooking/model/checkoutBookingBooked.test.ts

@@ -0,0 +1,14 @@
+import { checkoutBookingBooked as sut, CHECKOUT_BOOKING_BOOKED } from "./checkoutBookingBooked";
+
+describe("checkoutBookingBooked", () => {
+  it("returns an CheckoutBookingBooked domain event", () => {
+    const aggregateId = "d99810a4-a453-45b9-acc9-71896651e641";
+    const checkoutItemId = "b4563f59-9786-4544-aafe-405d9d21a6fc";
+
+    const domainEvent = sut({ aggregateId, checkoutItemId });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.checkoutItemId).toBe(checkoutItemId);
+    expect(domainEvent.name).toBe(CHECKOUT_BOOKING_BOOKED);
+  });
+});

package/src/domain/checkoutBooking/model/checkoutBookingBooked.ts

@@ -0,0 +1,25 @@
+import { domainEvent, DomainEvent, MessageName } from "@lookiero/messaging";
+
+const CHECKOUT_BOOKING_BOOKED = "checkout_booking_booked";
+
+interface CheckoutBookingBookedPayload {
+  readonly aggregateId: string;
+  readonly checkoutItemId: string;
+}
+
+interface CheckoutBookingBooked extends DomainEvent<typeof CHECKOUT_BOOKING_BOOKED>, CheckoutBookingBookedPayload {}
+
+interface CheckoutBookingBookedFunction {
+  (payload: CheckoutBookingBookedPayload): CheckoutBookingBooked;
+}
+
+const checkoutBookingBooked: CheckoutBookingBookedFunction = ({ aggregateId, ...payload }) => ({
+  ...domainEvent({ aggregateId, name: CHECKOUT_BOOKING_BOOKED }),
+  ...payload,
+});
+
+const isCheckoutBookingBooked = (event: DomainEvent<MessageName>): event is CheckoutBookingBooked =>
+  event.name === CHECKOUT_BOOKING_BOOKED;
+
+export type { CheckoutBookingBooked };
+export { CHECKOUT_BOOKING_BOOKED, checkoutBookingBooked, isCheckoutBookingBooked };

package/src/domain/checkoutBooking/model/checkoutBookingExpired.test.ts

@@ -0,0 +1,12 @@
+import { checkoutBookingExpired as sut, CHECKOUT_BOOKING_EXPIRED } from "./checkoutBookingExpired";
+
+describe("checkoutBookingExpired", () => {
+  it("returns an checkoutBookingExpired domain event", () => {
+    const aggregateId = "d99810a4-a453-45b9-acc9-71896651e641";
+
+    const domainEvent = sut({ aggregateId });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.name).toBe(CHECKOUT_BOOKING_EXPIRED);
+  });
+});

package/src/domain/checkoutBooking/model/checkoutBookingExpired.ts

@@ -0,0 +1,22 @@
+import { domainEvent, DomainEvent, MessageName } from "@lookiero/messaging";
+
+const CHECKOUT_BOOKING_EXPIRED = "checkout_booking_expired";
+
+interface CheckoutBookingExpiredPayload {
+  readonly aggregateId: string;
+}
+
+interface CheckoutBookingExpired extends DomainEvent<typeof CHECKOUT_BOOKING_EXPIRED>, CheckoutBookingExpiredPayload {}
+
+interface CheckoutBookingExpiredFunction {
+  (payload: CheckoutBookingExpiredPayload): CheckoutBookingExpired;
+}
+
+const checkoutBookingExpired: CheckoutBookingExpiredFunction = ({ aggregateId }) =>
+  domainEvent({ aggregateId, name: CHECKOUT_BOOKING_EXPIRED });
+
+const isCheckoutBookingExpired = (event: DomainEvent<MessageName>): event is CheckoutBookingExpired =>
+  event.name === CHECKOUT_BOOKING_EXPIRED;
+
+export type { CheckoutBookingExpired };
+export { CHECKOUT_BOOKING_EXPIRED, checkoutBookingExpired, isCheckoutBookingExpired };

package/src/domain/checkoutBooking/model/checkoutBookings.ts

@@ -0,0 +1,15 @@
+import {
+  RepositoryGetFunction,
+  RepositoryGetFunctionArgs,
+  RepositorySaveFunction,
+  RepositorySaveFunctionArgs,
+} from "@lookiero/messaging";
+import { CheckoutBooking } from "./checkoutBooking";
+
+interface CheckoutBookingsGetFunction<CheckoutBookingsGetFunctionArgs extends RepositoryGetFunctionArgs>
+  extends RepositoryGetFunction<CheckoutBooking, CheckoutBookingsGetFunctionArgs> {}
+
+interface CheckoutBookingsSaveFunction<CheckoutBookingsSaveFunctionArgs extends RepositorySaveFunctionArgs>
+  extends RepositorySaveFunction<CheckoutBooking, CheckoutBookingsSaveFunctionArgs> {}
+
+export type { CheckoutBookingsGetFunction, CheckoutBookingsSaveFunction };

package/src/domain/checkoutFeedback/command/giveCheckoutFeedback.test.ts

@@ -0,0 +1,13 @@
+import { giveCheckoutFeedback as sut, GIVE_CHECKOUT_FEEDBACK } from "./giveCheckoutFeedback";
+
+describe("giveCheckoutFeedback", () => {
+  it("returns a GiveCheckoutFeedback command", () => {
+    const checkoutId = "a2497ef8-48a8-4475-9f6e-30d15597de27";
+    const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+
+    const command = sut({ checkoutId, feedbacks });
+
+    expect(command.checkoutId).toBe(checkoutId);
+    expect(command.name).toBe(GIVE_CHECKOUT_FEEDBACK);
+  });
+});

package/src/domain/checkoutFeedback/command/giveCheckoutFeedback.ts

@@ -0,0 +1,23 @@
+import { command, Command } from "@lookiero/messaging";
+import { Feedbacks } from "../model/feedbacks";
+
+const GIVE_CHECKOUT_FEEDBACK = "give_checkout_feedback";
+
+interface GiveCheckoutFeedbackPayload {
+  readonly checkoutId: string;
+  readonly feedbacks: Feedbacks;
+}
+
+interface GiveCheckoutFeedback extends Command<typeof GIVE_CHECKOUT_FEEDBACK>, GiveCheckoutFeedbackPayload {}
+
+interface GiveCheckoutFeedbackFunction {
+  (payload: GiveCheckoutFeedbackPayload): GiveCheckoutFeedback;
+}
+
+const giveCheckoutFeedback: GiveCheckoutFeedbackFunction = (payload) => ({
+  ...command({ name: GIVE_CHECKOUT_FEEDBACK }),
+  ...payload,
+});
+
+export type { GiveCheckoutFeedback };
+export { GIVE_CHECKOUT_FEEDBACK, giveCheckoutFeedback };

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

@@ -0,0 +1,30 @@
+import { mock } from "jest-mock-extended";
+import { QueryBus } from "@lookiero/messaging";
+import { giveCheckoutFeedback } from "../command/giveCheckoutFeedback";
+import { CheckoutFeedback, giveCheckoutFeedbackHandler as sut } from "./checkoutFeedback";
+import { CHECKOUT_FEEDBACK_GIVEN } from "./checkoutFeedbackGiven";
+import { Feedbacks } from "./feedbacks";
+
+const checkoutId = "c533beb2-267e-4d4a-96ef-424ff8754bcd";
+const feedbacks: Feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+const checkoutFeedback: CheckoutFeedback = {
+  aggregateId: "5629461c-29f6-4944-b290-0ef1bdea38b4",
+  checkoutId,
+  feedbacks,
+  domainEvents: [],
+};
+
+describe("checkoutFeedback", () => {
+  const queryBus = mock<QueryBus>();
+
+  it("giveCheckoutFeedback", async () => {
+    const command = giveCheckoutFeedback({ checkoutId, feedbacks });
+
+    const aggregateRoot = await sut({ queryBus })({ aggregateRoot: checkoutFeedback, command });
+
+    expect(aggregateRoot.aggregateId).toBe(checkoutFeedback.aggregateId);
+    expect(aggregateRoot.checkoutId).toBe(checkoutFeedback.checkoutId);
+    expect(aggregateRoot.feedbacks).toBe(checkoutFeedback.feedbacks);
+    expect(aggregateRoot.domainEvents[0].name).toBe(CHECKOUT_FEEDBACK_GIVEN);
+  });
+});

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

@@ -0,0 +1,25 @@
+import { AggregateRoot, CommandHandlerFunction } from "@lookiero/messaging";
+import { GiveCheckoutFeedback } from "../command/giveCheckoutFeedback";
+import { checkoutFeedbackGiven } from "./checkoutFeedbackGiven";
+import { Feedbacks } from "./feedbacks";
+
+interface CheckoutFeedback extends AggregateRoot {
+  readonly checkoutId: string;
+  readonly feedbacks: Feedbacks;
+}
+
+const giveCheckoutFeedbackHandler: CommandHandlerFunction<GiveCheckoutFeedback, CheckoutFeedback> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId, checkoutId, feedbacks } = command;
+
+    return {
+      ...aggregateRoot,
+      checkoutId,
+      feedbacks,
+      domainEvents: [checkoutFeedbackGiven({ aggregateId, checkoutId })],
+    };
+  };
+
+export type { CheckoutFeedback };
+export { giveCheckoutFeedbackHandler };

package/src/domain/checkoutFeedback/model/checkoutFeedbackGiven.test.ts

@@ -0,0 +1,14 @@
+import { checkoutFeedbackGiven as sut, CHECKOUT_FEEDBACK_GIVEN } from "./checkoutFeedbackGiven";
+
+describe("checkoutFeedbackGiven", () => {
+  it("returns a CheckoutFeedbackGiven domain event", () => {
+    const aggregateId = "d49936cd-0292-47de-a4bc-0ac005069805";
+    const checkoutId = "c533beb2-267e-4d4a-96ef-424ff8754bcd";
+
+    const domainEvent = sut({ aggregateId, checkoutId });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.checkoutId).toBe(checkoutId);
+    expect(domainEvent.name).toBe(CHECKOUT_FEEDBACK_GIVEN);
+  });
+});

package/src/domain/checkoutFeedback/model/checkoutFeedbackGiven.ts

@@ -0,0 +1,25 @@
+import { domainEvent, DomainEvent, MessageName } from "@lookiero/messaging";
+
+const CHECKOUT_FEEDBACK_GIVEN = "checkout_feedback_given";
+
+interface CheckoutFeedbackGivenPayload {
+  readonly aggregateId: string;
+  readonly checkoutId: string;
+}
+
+interface CheckoutFeedbackGiven extends DomainEvent<typeof CHECKOUT_FEEDBACK_GIVEN>, CheckoutFeedbackGivenPayload {}
+
+interface CheckoutFeedbackGivenFunction {
+  (payload: CheckoutFeedbackGivenPayload): CheckoutFeedbackGiven;
+}
+
+const checkoutFeedbackGiven: CheckoutFeedbackGivenFunction = ({ aggregateId, ...payload }) => ({
+  ...domainEvent({ aggregateId, name: CHECKOUT_FEEDBACK_GIVEN }),
+  ...payload,
+});
+
+const isCheckoutFeedbackGiven = (event: DomainEvent<MessageName>): event is CheckoutFeedbackGiven =>
+  event.name === CHECKOUT_FEEDBACK_GIVEN;
+
+export type { CheckoutFeedbackGiven };
+export { CHECKOUT_FEEDBACK_GIVEN, checkoutFeedbackGiven, isCheckoutFeedbackGiven };

package/src/domain/checkoutFeedback/model/checkoutFeedbacks.ts

@@ -0,0 +1,15 @@
+import {
+  RepositoryGetFunction,
+  RepositoryGetFunctionArgs,
+  RepositorySaveFunction,
+  RepositorySaveFunctionArgs,
+} from "@lookiero/messaging";
+import { CheckoutFeedback } from "./checkoutFeedback";
+
+interface CheckoutFeedbacksGetFunction<CheckoutFeedbacksGetFunctionArgs extends RepositoryGetFunctionArgs>
+  extends RepositoryGetFunction<CheckoutFeedback, CheckoutFeedbacksGetFunctionArgs> {}
+
+interface CheckoutFeedbacksSaveFunction<CheckoutFeedbacksSaveFunctionArgs extends RepositorySaveFunctionArgs>
+  extends RepositorySaveFunction<CheckoutFeedback, CheckoutFeedbacksSaveFunctionArgs> {}
+
+export type { CheckoutFeedbacksGetFunction, CheckoutFeedbacksSaveFunction };

package/src/domain/checkoutFeedback/model/feedbacks.ts

@@ -0,0 +1,5 @@
+type CheckoutQuestionId = string;
+
+type Feedbacks = Record<CheckoutQuestionId, CheckoutQuestionId | string>; // uuid, uuid | free text
+
+export type { Feedbacks };

package/src/domain/checkoutItem/command/keepCheckoutItem.test.ts

@@ -0,0 +1,12 @@
+import { keepCheckoutItem as sut, KEEP_CHECKOUT_ITEM } from "./keepCheckoutItem";
+
+describe("keepCheckoutItem", () => {
+  it("returns a KeepCheckoutItem command", () => {
+    const aggregateId = "a2497ef8-48a8-4475-9f6e-30d15597de27";
+
+    const command = sut({ aggregateId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.name).toBe(KEEP_CHECKOUT_ITEM);
+  });
+});

package/src/domain/checkoutItem/command/keepCheckoutItem.ts

@@ -0,0 +1,19 @@
+import { command, Command } from "@lookiero/messaging";
+
+const KEEP_CHECKOUT_ITEM = "keep_checkout_item";
+
+interface KeepCheckoutItemPayload {
+  readonly aggregateId: string;
+}
+
+interface KeepCheckoutItem extends Command<typeof KEEP_CHECKOUT_ITEM>, KeepCheckoutItemPayload {}
+
+interface KeepCheckoutItemFunction {
+  (payload: KeepCheckoutItemPayload): KeepCheckoutItem;
+}
+
+const keepCheckoutItem: KeepCheckoutItemFunction = ({ aggregateId }) =>
+  command({ aggregateId, name: KEEP_CHECKOUT_ITEM });
+
+export type { KeepCheckoutItem };
+export { KEEP_CHECKOUT_ITEM, keepCheckoutItem };

package/src/domain/checkoutItem/command/replaceCheckoutItem.test.ts

@@ -0,0 +1,14 @@
+import { replaceCheckoutItem as sut, REPLACE_CHECKOUT_ITEM } from "./replaceCheckoutItem";
+
+describe("replaceCheckoutItem", () => {
+  it("returns a ReplaceCheckoutItem command", () => {
+    const aggregateId = "a2497ef8-48a8-4475-9f6e-30d15597de27";
+    const replacedForId = "134e12e3-b677-42eb-9d9d-3cc3bc215e93";
+
+    const command = sut({ aggregateId, replacedForId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.replacedForId).toBe(replacedForId);
+    expect(command.name).toBe(REPLACE_CHECKOUT_ITEM);
+  });
+});

package/src/domain/checkoutItem/command/replaceCheckoutItem.ts

@@ -0,0 +1,22 @@
+import { command, Command } from "@lookiero/messaging";
+
+const REPLACE_CHECKOUT_ITEM = "replace_checkout_item";
+
+interface ReplaceCheckoutItemPayload {
+  readonly aggregateId: string;
+  readonly replacedForId: string;
+}
+
+interface ReplaceCheckoutItem extends Command<typeof REPLACE_CHECKOUT_ITEM>, ReplaceCheckoutItemPayload {}
+
+interface ReplaceCheckoutItemFunction {
+  (payload: ReplaceCheckoutItemPayload): ReplaceCheckoutItem;
+}
+
+const replaceCheckoutItem: ReplaceCheckoutItemFunction = ({ aggregateId, ...payload }) => ({
+  ...command({ aggregateId, name: REPLACE_CHECKOUT_ITEM }),
+  ...payload,
+});
+
+export type { ReplaceCheckoutItem };
+export { REPLACE_CHECKOUT_ITEM, replaceCheckoutItem };

package/src/domain/checkoutItem/command/resetCheckoutItem.test.ts

@@ -0,0 +1,12 @@
+import { resetCheckoutItem as sut, RESET_CHECKOUT_ITEM } from "./resetCheckoutItem";
+
+describe("resetCheckoutItem", () => {
+  it("returns a ResetCheckoutItem command", () => {
+    const aggregateId = "a2497ef8-48a8-4475-9f6e-30d15597de27";
+
+    const command = sut({ aggregateId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.name).toBe(RESET_CHECKOUT_ITEM);
+  });
+});

package/src/domain/checkoutItem/command/resetCheckoutItem.ts

@@ -0,0 +1,19 @@
+import { command, Command } from "@lookiero/messaging";
+
+const RESET_CHECKOUT_ITEM = "reset_checkout_item";
+
+interface ResetCheckoutItemPayload {
+  readonly aggregateId: string;
+}
+
+interface ResetCheckoutItem extends Command<typeof RESET_CHECKOUT_ITEM>, ResetCheckoutItemPayload {}
+
+interface ResetCheckoutItemFunction {
+  (payload: ResetCheckoutItemPayload): ResetCheckoutItem;
+}
+
+const resetCheckoutItem: ResetCheckoutItemFunction = ({ aggregateId }) =>
+  command({ aggregateId, name: RESET_CHECKOUT_ITEM });
+
+export type { ResetCheckoutItem };
+export { RESET_CHECKOUT_ITEM, resetCheckoutItem };

package/src/domain/checkoutItem/command/returnCheckoutItem.test.ts

@@ -0,0 +1,13 @@
+import { returnCheckoutItem as sut, RETURN_CHECKOUT_ITEM } from "./returnCheckoutItem";
+
+describe("returnCheckoutItem", () => {
+  it("returns a ReturnCheckoutItem command", () => {
+    const aggregateId = "a2497ef8-48a8-4475-9f6e-30d15597de27";
+    const feedbacks = { ["9b389f01-50f9-42cb-89dd-850fbb2dce5b"]: "Feedback text" };
+
+    const command = sut({ aggregateId, feedbacks });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.name).toBe(RETURN_CHECKOUT_ITEM);
+  });
+});

package/src/domain/checkoutItem/command/returnCheckoutItem.ts

@@ -0,0 +1,23 @@
+import { command, Command } from "@lookiero/messaging";
+import { Feedbacks } from "../model/feedbacks";
+
+const RETURN_CHECKOUT_ITEM = "return_checkout_item";
+
+interface ReturnCheckoutItemPayload {
+  readonly aggregateId: string;
+  readonly feedbacks: Feedbacks;
+}
+
+interface ReturnCheckoutItem extends Command<typeof RETURN_CHECKOUT_ITEM>, ReturnCheckoutItemPayload {}
+
+interface ReturnCheckoutItemFunction {
+  (payload: ReturnCheckoutItemPayload): ReturnCheckoutItem;
+}
+
+const returnCheckoutItem: ReturnCheckoutItemFunction = ({ aggregateId, ...payload }) => ({
+  ...command({ aggregateId, name: RETURN_CHECKOUT_ITEM }),
+  ...payload,
+});
+
+export type { ReturnCheckoutItem };
+export { RETURN_CHECKOUT_ITEM, returnCheckoutItem };

package/src/domain/checkoutItem/event/createModalNotificationWhenCheckoutItemReplaced.test.ts

@@ -0,0 +1,31 @@
+import { NotificationType } from "@lookiero/sty-psp-notifications/dist/src/domain/notification/model/notification";
+import { I18nMessages } from "../../../infrastructure/ui/i18n/i18n";
+import { checkoutItemReplaced } from "../model/checkoutItemReplaced";
+import {
+  SIZE_CHANGE_NOTIFICATION_ID,
+  createModalNotificationWhenCheckoutItemReplaced as sut,
+} from "./createModalNotificationWhenCheckoutItemReplaced";
+
+const aggregateId = "2819b35f-6c40-4ec1-953d-6a5e6ebff462";
+
+describe("createModalNotificationWhenCheckoutItemReplaced", () => {
+  const queryBus = jest.fn();
+  const commandBus = jest.fn();
+
+  test("create a modal notification when checkoutItemReplaced occurred", async () => {
+    const checkoutItemReplacedEvent = checkoutItemReplaced({ aggregateId });
+
+    await sut({ queryBus, commandBus })(checkoutItemReplacedEvent);
+
+    expect(commandBus).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aggregateId: SIZE_CHANGE_NOTIFICATION_ID,
+        name: "create_modal_notification",
+        type: NotificationType.MODAL,
+        titleI18nKey: I18nMessages.SIZE_CHANGE_MODAL_TITLE,
+        bodyI18nKey: I18nMessages.SIZE_CHANGE_MODAL_DESCRIPTION,
+        acceptI18nKey: I18nMessages.SIZE_CHANGE_MODAL_BUTTON,
+      }),
+    );
+  });
+});

package/src/domain/checkoutItem/event/createModalNotificationWhenCheckoutItemReplaced.ts

@@ -0,0 +1,24 @@
+import { ProcessManagerFunction } from "@lookiero/messaging";
+import { createModalNotification } from "@lookiero/sty-psp-notifications";
+import { I18nMessages } from "../../../infrastructure/ui/i18n/i18n";
+import { CheckoutItemReplaced } from "../model/checkoutItemReplaced";
+
+const SIZE_CHANGE_NOTIFICATION_ID = "ce89b8b2-e025-4b54-8cdc-52520dc3dd23";
+
+interface CreateModalNotificationWhenCheckoutItemReplacedFunction
+  extends ProcessManagerFunction<CheckoutItemReplaced> {}
+
+const createModalNotificationWhenCheckoutItemReplaced: CreateModalNotificationWhenCheckoutItemReplacedFunction =
+  ({ commandBus }) =>
+  async () => {
+    await commandBus(
+      createModalNotification({
+        aggregateId: SIZE_CHANGE_NOTIFICATION_ID,
+        titleI18nKey: I18nMessages.SIZE_CHANGE_MODAL_TITLE,
+        bodyI18nKey: I18nMessages.SIZE_CHANGE_MODAL_DESCRIPTION,
+        acceptI18nKey: I18nMessages.SIZE_CHANGE_MODAL_BUTTON,
+      }),
+    );
+  };
+
+export { createModalNotificationWhenCheckoutItemReplaced, SIZE_CHANGE_NOTIFICATION_ID };