@lookiero/checkout 5.3.0 → 6.0.0-beta.1

package/src/Expo.tsx

@@ -0,0 +1,7 @@
+import { registerRootComponent } from "expo";
+import { enableLegacyWebImplementation } from "react-native-gesture-handler";
+import { ExpoRoot } from "./ExpoRoot";
+
+enableLegacyWebImplementation(true);
+
+registerRootComponent(ExpoRoot);

package/src/ExpoRoot.tsx

@@ -0,0 +1,193 @@
+import { useFonts } from "expo-font";
+import "expo/build/Expo.fx";
+import React, { FC, useCallback, useState } from "react";
+import { Platform, ScrollView } from "react-native";
+import "react-native-get-random-values";
+import { Navigate, Route, Routes } from "react-router-native";
+import { Aurora, Text } from "@lookiero/aurora";
+import { EventProvider } from "@lookiero/event";
+import { EndpointFunction } from "@lookiero/i18n";
+import { i18n } from "@lookiero/i18n-react";
+import { PaymentsQueryProvider, setPaymentsBridge } from "@lookiero/payments-front";
+import { Locale } from "@lookiero/sty-psp-locale";
+import { SentryEnvironment } from "@lookiero/sty-psp-logging";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { KameleoonEnvironment } from "./infrastructure/ab-testing/kameleoonEnvironment";
+// import { bootstrap as checkoutMockBootstrap } from "./infrastructure/delivery/bootstrap.mock";
+import { bootstrap as checkoutBootstrap } from "./infrastructure/delivery/bootstrap";
+import { root } from "./infrastructure/ui/Root";
+import { DummyLayout } from "./infrastructure/ui/components/layouts/layout/dummyLayout/DummyLayout";
+import { fetchTranslations } from "./infrastructure/ui/i18n/fetchTranslations";
+import { translationExternalEndpoint } from "./infrastructure/ui/i18n/translationEndpoint";
+import { Router } from "./infrastructure/ui/routing/router/Router";
+import { Country } from "./projection/shared/country";
+import { Customer } from "./projection/shared/customer";
+import { VERSION } from "./version";
+
+const locale: Locale = Locale.ES;
+
+const customer: Customer = {
+  customerId: "51a031b1-01e6-4717-97e5-157eb5a96953",
+  country: Country.ES,
+  segment: Segment.WOMEN,
+};
+
+const sentryConfig: SentryEnvironment = {
+  publicKey: "66cadf9444db4ea5945670f12ec08ae7",
+  release: VERSION,
+  project: "4504400729276416",
+  environment: `${Platform.OS}-EXPO`,
+};
+
+const apiUrl =
+  Platform.OS !== "web" ? "https://web2.sp.dev.aws.lookiero.es/quiz/api" : __DEV__ ? "/local-to-dev" : "/checkout/api";
+const authToken =
+  "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOjUwNDY3MDcsImV4cCI6MTcxOTc0MTYzMCwiZGlzcGxheU5hbWUiOiJNaWtlbCIsImNvdW50cnlfY29kZSI6IkVTIiwiYWNjZXNzVmlhIjoiZW1haWwiLCJzdWJzY3JpcHRpb25TdGFydGluZ0RhdGUiOiIyMDI0LTA1LTI5IiwiaW1wZXJzb25hdGVkIjpmYWxzZSwidXVpZCI6IjUxYTAzMWIxLTAxZTYtNDcxNy05N2U1LTE1N2ViNWE5Njk1MyIsImlhdCI6MTcxNzA2MzIzMH0.k8T3SdiOVu0UkRqPI6QlFDldI9Dgi0p0nT0i9dwc2lU";
+const getAuthToken = () => Promise.resolve(authToken);
+
+const externalTranslationsUrl =
+  Platform.OS !== "web"
+    ? "https://backend-for-user.dev.envs.lookiero.tech/api/v2/translations"
+    : __DEV__
+      ? "/local-to-external-i18n"
+      : "/external-i18n";
+const translations: EndpointFunction[] = [
+  (locale) =>
+    translationExternalEndpoint({
+      translationsUrl: externalTranslationsUrl,
+      projects: [["user-area-front"], ["inventory-catalog", "feature;feature_value;Color"], ["checkout"]],
+    })(locale),
+];
+
+const useRedirect: () => Record<string, string> = () => ({
+  returnUrl: "https://web2.dev.aws.lookiero.es/user/",
+});
+
+setPaymentsBridge({
+  getToken: getAuthToken,
+  stripeKey: "pk_test_6dwdUfkUm7AaUH3oSje9H0kk",
+  stripeUkKey:
+    "pk_test_51Jw6NEHQ1gSUXaQ8KKBLBhmzw7k0TCTN0GQ6qq8oGRmXCn09ptn7zrHX5jsyidv8iBDGuzUDV3R0fko01m5oJzMO00z6XmoLbn",
+  commonAssetsPath: "https://cdn.dev.envs.lookiero.tech/commons",
+  paymentsAssetsPath: "https://cdn.dev.envs.lookiero.tech/payments-front",
+  useAvoidKeyboard: () => ({
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    setAvoidKeyboard: () => void 0,
+  }),
+  emitTrackingEvent: (e) => {
+    console.log("Tracking Payment event", e);
+  },
+  appVersion: VERSION,
+  graphqlUri: "/graphql",
+  googlePay: {
+    merchant: {
+      merchantId: "0123456789",
+      merchantName: "Lookiero",
+    },
+    isTestEnv: true,
+  },
+  useFeatureFlags: () => ({
+    /* eslint-disable @typescript-eslint/naming-convention */
+    ALLOW_GOOGLE_PAY_AT: true,
+    ALLOW_GOOGLE_PAY_BE: true,
+    ALLOW_GOOGLE_PAY_DE: true,
+    ALLOW_GOOGLE_PAY_ES: true,
+    ALLOW_GOOGLE_PAY_FR: true,
+    ALLOW_GOOGLE_PAY_GB: true,
+    ALLOW_GOOGLE_PAY_IT: true,
+    ALLOW_GOOGLE_PAY_LU: true,
+    ALLOW_GOOGLE_PAY_NL: true,
+    ALLOW_GOOGLE_PAY_PT: true,
+    ALLOW_GOOGLE_PAY_APP_AT: true,
+    ALLOW_GOOGLE_PAY_APP_BE: true,
+    ALLOW_GOOGLE_PAY_APP_DE: true,
+    ALLOW_GOOGLE_PAY_APP_ES: true,
+    ALLOW_GOOGLE_PAY_APP_FR: true,
+    ALLOW_GOOGLE_PAY_APP_GB: true,
+    ALLOW_GOOGLE_PAY_APP_IT: true,
+    ALLOW_GOOGLE_PAY_APP_LU: true,
+    ALLOW_GOOGLE_PAY_APP_NL: true,
+    ALLOW_GOOGLE_PAY_APP_PT: true,
+    /* eslint-enable @typescript-eslint/naming-convention */
+  }),
+  locale: () => Promise.resolve("es-ES"),
+  scrollView: ScrollView,
+});
+
+const kameleoonConfig: KameleoonEnvironment = {
+  siteCode: "aplm4v3ckn",
+  experiments: {
+    newFeedback: {
+      id: "245000",
+      variations: {
+        v1: "964072",
+      },
+    },
+  },
+};
+
+// const { Component: Messaging } = checkoutMockBootstrap();
+const { Component: Messaging } = checkoutBootstrap({ apiUrl: () => apiUrl, getAuthToken });
+const I18n = i18n({
+  fetchTranslation: fetchTranslations({ translations }),
+  contextId: "CheckoutI18n",
+});
+const Root = root({
+  Messaging,
+  I18n,
+  getAuthToken,
+  development: false,
+  sentry: () => sentryConfig,
+  kameleoon: () => kameleoonConfig,
+})({ customerId: customer.customerId });
+
+const ExpoRoot: FC = () => {
+  const [fontsLoaded] = useFonts({
+    ["AreaInktrap-Semibold"]: require("@lookiero/aurora-fonts/AreaInktrap-Semibold.otf"),
+    ["AreaNormal-Semibold"]: require("@lookiero/aurora-fonts/AreaNormal-Semibold.otf"),
+    ["AreaNormal-Extrabold"]: require("@lookiero/aurora-fonts/AreaNormal-Extrabold.otf"),
+    auroraicons: require("@lookiero/aurora-iconfont/dist/auroraicons.ttf"),
+  });
+
+  const [isAccessible, setIsAccessible] = useState<boolean>();
+  const onNotAccessible = useCallback(() => setIsAccessible(false), []);
+
+  return fontsLoaded ? (
+    <PaymentsQueryProvider>
+      <EventProvider>
+        <Aurora>
+          {isAccessible === false && <Text heading={true}>Checkout is not accessible!</Text>}
+
+          <Router>
+            <Routes>
+              <Route
+                path="/checkout/*"
+                element={
+                  <Root
+                    basePath="/checkout"
+                    customer={customer}
+                    layout={DummyLayout}
+                    locale={locale}
+                    subscription="b"
+                    useRedirect={useRedirect}
+                    order={{
+                      isFirstOrder: false,
+                      orderNumber: 3687582,
+                      coupon: "MYLOOKIERO",
+                    }}
+                    onNotAccessible={onNotAccessible}
+                  />
+                }
+              />
+
+              <Route element={<Navigate to="/checkout" replace />} path="*" />
+            </Routes>
+          </Router>
+        </Aurora>
+      </EventProvider>
+    </PaymentsQueryProvider>
+  ) : null;
+};
+
+export { ExpoRoot };

package/src/domain/checkout/command/startCheckout.test.ts

@@ -0,0 +1,12 @@
+import { startCheckout as sut, START_CHECKOUT } from "./startCheckout";
+
+describe("startCheckout", () => {
+  it("returns an startCheckout command", () => {
+    const aggregateId = "67ac1d5c-6d24-4b19-bc01-8f61c266670c";
+
+    const command = sut({ aggregateId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.name).toBe(START_CHECKOUT);
+  });
+});

package/src/domain/checkout/command/startCheckout.ts

@@ -0,0 +1,18 @@
+import { command, Command } from "@lookiero/messaging";
+
+const START_CHECKOUT = "start_checkout";
+
+interface StartCheckoutPayload {
+  readonly aggregateId: string;
+}
+
+interface StartCheckout extends Command<typeof START_CHECKOUT>, StartCheckoutPayload {}
+
+interface StartCheckoutFunction {
+  (payload: StartCheckoutPayload): StartCheckout;
+}
+
+const startCheckout: StartCheckoutFunction = ({ aggregateId }) => command({ aggregateId, name: START_CHECKOUT });
+
+export type { StartCheckout };
+export { START_CHECKOUT, startCheckout };

package/src/domain/checkout/command/submitCheckout.test.ts

@@ -0,0 +1,12 @@
+import { submitCheckout as sut, SUBMIT_CHECKOUT } from "./submitCheckout";
+
+describe("submitCheckout", () => {
+  it("returns an submitCheckout command", () => {
+    const aggregateId = "67ac1d5c-6d24-4b19-bc01-8f61c266670c";
+
+    const command = sut({ aggregateId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.name).toBe(SUBMIT_CHECKOUT);
+  });
+});

package/src/domain/checkout/command/submitCheckout.ts

@@ -0,0 +1,18 @@
+import { command, Command } from "@lookiero/messaging";
+
+const SUBMIT_CHECKOUT = "submit_checkout";
+
+interface SubmitCheckoutPayload {
+  readonly aggregateId: string;
+}
+
+interface SubmitCheckout extends Command<typeof SUBMIT_CHECKOUT>, SubmitCheckoutPayload {}
+
+interface SubmitCheckoutFunction {
+  (payload: SubmitCheckoutPayload): SubmitCheckout;
+}
+
+const submitCheckout: SubmitCheckoutFunction = ({ aggregateId }) => command({ aggregateId, name: SUBMIT_CHECKOUT });
+
+export type { SubmitCheckout };
+export { SUBMIT_CHECKOUT, submitCheckout };

package/src/domain/checkout/event/createModalNotificationWhenCheckoutSubmitted.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 { checkoutSubmitted } from "../model/checkoutSubmitted";
+import {
+  CHECKOUT_SUCCESS_NOTIFICATION_ID,
+  createModalNotificationWhenCheckoutSubmitted as sut,
+} from "./createModalNotificationWhenCheckoutSubmitted";
+
+const aggregateId = "ac941883-271a-4566-94b3-4f79b4a22c7c";
+
+describe("createModalNotificationWhenCheckoutSubmitted", () => {
+  const queryBus = jest.fn();
+  const commandBus = jest.fn();
+
+  test("create a modal notification when checkoutSubmitted occurred", async () => {
+    const checkoutSubmittedEvent = checkoutSubmitted({ aggregateId });
+
+    await sut({ queryBus, commandBus })(checkoutSubmittedEvent);
+
+    expect(commandBus).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aggregateId: CHECKOUT_SUCCESS_NOTIFICATION_ID,
+        name: "create_modal_notification",
+        type: NotificationType.MODAL,
+        titleI18nKey: I18nMessages.CHECKOUT_SUCCESS_MODAL_TITLE,
+        bodyI18nKey: I18nMessages.CHECKOUT_SUCCESS_MODAL_DESCRIPTION,
+        acceptI18nKey: I18nMessages.CHECKOUT_SUCCESS_MODAL_BUTTON,
+      }),
+    );
+  });
+});

package/src/domain/checkout/event/createModalNotificationWhenCheckoutSubmitted.ts

@@ -0,0 +1,23 @@
+import { ProcessManagerFunction } from "@lookiero/messaging";
+import { createModalNotification } from "@lookiero/sty-psp-notifications";
+import { I18nMessages } from "../../../infrastructure/ui/i18n/i18n";
+import { CheckoutSubmitted } from "../model/checkoutSubmitted";
+
+const CHECKOUT_SUCCESS_NOTIFICATION_ID = "fa25dcdd-9f5d-4760-9e6f-27174205b1fa";
+
+interface CreateModalNotificationWhenCheckoutSubmittedFunction extends ProcessManagerFunction<CheckoutSubmitted> {}
+
+const createModalNotificationWhenCheckoutSubmitted: CreateModalNotificationWhenCheckoutSubmittedFunction =
+  ({ commandBus }) =>
+  async () => {
+    await commandBus(
+      createModalNotification({
+        aggregateId: CHECKOUT_SUCCESS_NOTIFICATION_ID,
+        titleI18nKey: I18nMessages.CHECKOUT_SUCCESS_MODAL_TITLE,
+        bodyI18nKey: I18nMessages.CHECKOUT_SUCCESS_MODAL_DESCRIPTION,
+        acceptI18nKey: I18nMessages.CHECKOUT_SUCCESS_MODAL_BUTTON,
+      }),
+    );
+  };
+
+export { createModalNotificationWhenCheckoutSubmitted, CHECKOUT_SUCCESS_NOTIFICATION_ID };

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

@@ -0,0 +1,77 @@
+import { mock } from "jest-mock-extended";
+import { QueryBus } from "@lookiero/messaging";
+import { startCheckout } from "../command/startCheckout";
+import { submitCheckout } from "../command/submitCheckout";
+import {
+  Checkout,
+  CheckoutStatus,
+  startCheckoutHandler as sutStart,
+  submitCheckoutHandler as sutSubmit,
+} from "./checkout";
+import { CHECKOUT_STARTED } from "./checkoutStarted";
+import { CHECKOUT_SUBMITTED } from "./checkoutSubmitted";
+
+const checkoutWithStatus = (status: CheckoutStatus): Checkout => ({
+  aggregateId: "fcb1a564-67be-40a1-9d7a-33dbd1e00062",
+  status,
+  customerId: "6f1c2968-e3d5-4cf0-9fbb-292c5ef46da2",
+  boxId: "9e283955-d25e-42c9-bf29-7f6d1c40fb69",
+  checkoutBookingId: "1f2125e2-c1d6-4cf1-84f2-5ac39de1116f",
+  expiresOn: new Date(),
+  domainEvents: [],
+});
+
+describe("checkout", () => {
+  const queryBus = mock<QueryBus>();
+
+  it("starts", async () => {
+    const checkout: Checkout = checkoutWithStatus(CheckoutStatus.NOTIFIED);
+    const command = startCheckout({ aggregateId: checkout.aggregateId });
+
+    const aggregateRoot = await sutStart({ queryBus })({ aggregateRoot: checkout, command });
+
+    expect(aggregateRoot.aggregateId).toBe(checkout.aggregateId);
+    expect(aggregateRoot.checkoutBookingId).toBe(checkout.checkoutBookingId);
+    expect(aggregateRoot.boxId).toBe(checkout.boxId);
+    expect(aggregateRoot.customerId).toBe(checkout.customerId);
+    expect(aggregateRoot.expiresOn).toBe(checkout.expiresOn);
+    expect(aggregateRoot.status).toBe(CheckoutStatus.STARTED);
+    expect(aggregateRoot.domainEvents[0].name).toBe(CHECKOUT_STARTED);
+  });
+
+  it("throws if trying to start and already started", async () => {
+    const checkout: Checkout = checkoutWithStatus(CheckoutStatus.STARTED);
+    const command = startCheckout({ aggregateId: checkout.aggregateId });
+
+    expect(async () => await sutStart({ queryBus })({ aggregateRoot: checkout, command })).rejects.toThrow();
+  });
+
+  it("throws if trying to start a completed checkout", async () => {
+    const checkout: Checkout = checkoutWithStatus(CheckoutStatus.COMPLETED);
+    const command = startCheckout({ aggregateId: checkout.aggregateId });
+
+    expect(async () => await sutStart({ queryBus })({ aggregateRoot: checkout, command })).rejects.toThrow();
+  });
+
+  it("submit checkout", async () => {
+    const checkout: Checkout = checkoutWithStatus(CheckoutStatus.STARTED);
+    const command = submitCheckout({ aggregateId: checkout.aggregateId });
+
+    const aggregateRoot = await sutSubmit({ queryBus })({ aggregateRoot: checkout, command });
+
+    expect(aggregateRoot.aggregateId).toBe(checkout.aggregateId);
+    expect(aggregateRoot.checkoutBookingId).toBe(checkout.checkoutBookingId);
+    expect(aggregateRoot.boxId).toBe(checkout.boxId);
+    expect(aggregateRoot.customerId).toBe(checkout.customerId);
+    expect(aggregateRoot.expiresOn).toBe(checkout.expiresOn);
+    expect(aggregateRoot.status).toBe(CheckoutStatus.SUBMITTED);
+    expect(aggregateRoot.domainEvents[0].name).toBe(CHECKOUT_SUBMITTED);
+  });
+
+  it("throws if trying to submit checkout a completed checkout", async () => {
+    const checkout: Checkout = checkoutWithStatus(CheckoutStatus.COMPLETED);
+    const command = submitCheckout({ aggregateId: checkout.aggregateId });
+
+    expect(async () => await sutSubmit({ queryBus })({ aggregateRoot: checkout, command })).rejects.toThrow();
+  });
+});

package/src/domain/checkout/model/checkout.ts

@@ -0,0 +1,55 @@
+import invariant from "tiny-invariant";
+import { AggregateRoot, CommandHandlerFunction } from "@lookiero/messaging";
+import { StartCheckout } from "../command/startCheckout";
+import { SubmitCheckout } from "../command/submitCheckout";
+import { checkoutStarted } from "./checkoutStarted";
+import { checkoutSubmitted } from "./checkoutSubmitted";
+
+enum CheckoutStatus {
+  AVAILABLE = "AVAILABLE",
+  NOTIFIED = "NOTIFIED",
+  STARTED = "STARTED",
+  SUBMITTED = "SUBMITTED",
+  COMPLETED = "COMPLETED",
+}
+
+interface Checkout extends AggregateRoot {
+  readonly status: CheckoutStatus;
+  readonly customerId: string;
+  readonly boxId: string;
+  readonly checkoutBookingId: string;
+  readonly expiresOn: Date;
+}
+
+const startCheckoutHandler: CommandHandlerFunction<StartCheckout, Checkout> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId } = command;
+
+    invariant(aggregateRoot.status !== CheckoutStatus.STARTED, "Checkout is already started");
+    invariant(aggregateRoot.status !== CheckoutStatus.SUBMITTED, "Checkout is already submitted");
+    invariant(aggregateRoot.status !== CheckoutStatus.COMPLETED, "Checkout is already completed");
+
+    return {
+      ...aggregateRoot,
+      status: CheckoutStatus.STARTED,
+      domainEvents: [checkoutStarted({ aggregateId })],
+    };
+  };
+
+const submitCheckoutHandler: CommandHandlerFunction<SubmitCheckout, Checkout> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId } = command;
+
+    invariant(aggregateRoot.status !== CheckoutStatus.COMPLETED, "Checkout is already completed");
+
+    return {
+      ...aggregateRoot,
+      status: CheckoutStatus.SUBMITTED,
+      domainEvents: [checkoutSubmitted({ aggregateId })],
+    };
+  };
+
+export type { Checkout };
+export { CheckoutStatus, startCheckoutHandler, submitCheckoutHandler };

package/src/domain/checkout/model/checkoutStarted.test.ts

@@ -0,0 +1,12 @@
+import { checkoutStarted as sut, CHECKOUT_STARTED } from "./checkoutStarted";
+
+describe("checkoutStarted", () => {
+  it("returns an CheckoutStarted domain event", () => {
+    const aggregateId = "44f9b453-e49a-4682-b28a-be26936f5eda";
+
+    const domainEvent = sut({ aggregateId });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.name).toBe(CHECKOUT_STARTED);
+  });
+});

package/src/domain/checkout/model/checkoutStarted.ts

@@ -0,0 +1,22 @@
+import { domainEvent, DomainEvent, MessageName } from "@lookiero/messaging";
+
+const CHECKOUT_STARTED = "checkout_started";
+
+interface CheckoutStartedPayload {
+  readonly aggregateId: string;
+}
+
+interface CheckoutStarted extends DomainEvent<typeof CHECKOUT_STARTED>, CheckoutStartedPayload {}
+
+interface CheckoutStartedFunction {
+  (payload: CheckoutStartedPayload): CheckoutStarted;
+}
+
+const checkoutStarted: CheckoutStartedFunction = ({ aggregateId }) =>
+  domainEvent({ aggregateId, name: CHECKOUT_STARTED });
+
+const isCheckoutStarted = (event: DomainEvent<MessageName>): event is CheckoutStarted =>
+  event.name === CHECKOUT_STARTED;
+
+export type { CheckoutStarted };
+export { CHECKOUT_STARTED, checkoutStarted, isCheckoutStarted };

package/src/domain/checkout/model/checkoutSubmitted.test.ts

@@ -0,0 +1,12 @@
+import { checkoutSubmitted as sut, CHECKOUT_SUBMITTED } from "./checkoutSubmitted";
+
+describe("checkoutSubmitted", () => {
+  it("returns an CheckoutSubmitted domain event", () => {
+    const aggregateId = "44f9b453-e49a-4682-b28a-be26936f5eda";
+
+    const domainEvent = sut({ aggregateId });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.name).toBe(CHECKOUT_SUBMITTED);
+  });
+});

package/src/domain/checkout/model/checkoutSubmitted.ts

@@ -0,0 +1,22 @@
+import { domainEvent, DomainEvent, MessageName } from "@lookiero/messaging";
+
+const CHECKOUT_SUBMITTED = "checkout_submitted";
+
+interface CheckoutSubmittedPayload {
+  readonly aggregateId: string;
+}
+
+interface CheckoutSubmitted extends DomainEvent<typeof CHECKOUT_SUBMITTED>, CheckoutSubmittedPayload {}
+
+interface CheckoutSubmittedFunction {
+  (payload: CheckoutSubmittedPayload): CheckoutSubmitted;
+}
+
+const checkoutSubmitted: CheckoutSubmittedFunction = ({ aggregateId }) =>
+  domainEvent({ aggregateId, name: CHECKOUT_SUBMITTED });
+
+const isCheckoutSubmitted = (event: DomainEvent<MessageName>): event is CheckoutSubmitted =>
+  event.name === CHECKOUT_SUBMITTED;
+
+export type { CheckoutSubmitted };
+export { CHECKOUT_SUBMITTED, checkoutSubmitted, isCheckoutSubmitted };

package/src/domain/checkout/model/checkouts.ts

@@ -0,0 +1,15 @@
+import {
+  RepositoryGetFunction,
+  RepositoryGetFunctionArgs,
+  RepositorySaveFunction,
+  RepositorySaveFunctionArgs,
+} from "@lookiero/messaging";
+import { Checkout } from "./checkout";
+
+interface CheckoutsGetFunction<CheckoutsGetFunctionArgs extends RepositoryGetFunctionArgs>
+  extends RepositoryGetFunction<Checkout, CheckoutsGetFunctionArgs> {}
+
+interface CheckoutsSaveFunction<CheckoutsSaveFunctionArgs extends RepositorySaveFunctionArgs>
+  extends RepositorySaveFunction<Checkout, CheckoutsSaveFunctionArgs> {}
+
+export type { CheckoutsGetFunction, CheckoutsSaveFunction };

package/src/domain/checkoutBooking/command/blockCheckoutBooking.test.ts

@@ -0,0 +1,12 @@
+import { blockCheckoutBooking as sut, BLOCK_CHECKOUT_BOOKING } from "./blockCheckoutBooking";
+
+describe("blockCheckoutBooking", () => {
+  it("returns an BlockCheckoutBooking command", () => {
+    const aggregateId = "118f0698-a194-4edf-9f30-e936f985fde0";
+
+    const command = sut({ aggregateId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.name).toBe(BLOCK_CHECKOUT_BOOKING);
+  });
+});

package/src/domain/checkoutBooking/command/blockCheckoutBooking.ts

@@ -0,0 +1,19 @@
+import { command, Command } from "@lookiero/messaging";
+
+const BLOCK_CHECKOUT_BOOKING = "block_checkout_booking";
+
+interface BlockCheckoutBookingPayload {
+  readonly aggregateId: string;
+}
+
+interface BlockCheckoutBooking extends Command<typeof BLOCK_CHECKOUT_BOOKING>, BlockCheckoutBookingPayload {}
+
+interface BlockCheckoutBookingFunction {
+  (payload: BlockCheckoutBookingPayload): BlockCheckoutBooking;
+}
+
+const blockCheckoutBooking: BlockCheckoutBookingFunction = ({ aggregateId }) =>
+  command({ aggregateId, name: BLOCK_CHECKOUT_BOOKING });
+
+export type { BlockCheckoutBooking };
+export { BLOCK_CHECKOUT_BOOKING, blockCheckoutBooking };

package/src/domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem.test.ts

@@ -0,0 +1,17 @@
+import {
+  bookCheckoutBookingForCheckoutItem as sut,
+  BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM,
+} from "./bookCheckoutBookingForCheckoutItem";
+
+describe("bookCheckoutBookingForCheckoutItem", () => {
+  it("returns an bookCheckoutBookingForCheckoutItem command", () => {
+    const aggregateId = "118f0698-a194-4edf-9f30-e936f985fde0";
+    const checkoutItemId = "8ac1c68c-baee-454a-bb9b-71dd2dfa0dfa";
+
+    const command = sut({ aggregateId, checkoutItemId });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.checkoutItemId).toBe(checkoutItemId);
+    expect(command.name).toBe(BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM);
+  });
+});

package/src/domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem.ts

@@ -0,0 +1,27 @@
+import { command, Command } from "@lookiero/messaging";
+
+const BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM = "book_checkout_booking_for_checkout_item";
+
+interface BookCheckoutBookingForCheckoutItemPayload {
+  readonly aggregateId: string;
+  readonly checkoutItemId: string;
+}
+
+interface BookCheckoutBookingForCheckoutItem
+  extends Command<typeof BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM>,
+    BookCheckoutBookingForCheckoutItemPayload {}
+
+interface BookCheckoutBookingForCheckoutItemFunction {
+  (payload: BookCheckoutBookingForCheckoutItemPayload): BookCheckoutBookingForCheckoutItem;
+}
+
+const bookCheckoutBookingForCheckoutItem: BookCheckoutBookingForCheckoutItemFunction = ({
+  aggregateId,
+  ...payload
+}) => ({
+  ...command({ aggregateId, name: BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM }),
+  ...payload,
+});
+
+export type { BookCheckoutBookingForCheckoutItem };
+export { BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM, bookCheckoutBookingForCheckoutItem };

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

@@ -0,0 +1,33 @@
+import {
+  NotificationLevel,
+  NotificationType,
+} from "@lookiero/sty-psp-notifications/dist/src/domain/notification/model/notification";
+import { I18nMessages } from "../../../infrastructure/ui/i18n/i18n";
+import { checkoutBookingExpired } from "../model/checkoutBookingExpired";
+import {
+  CHECKOUT_BOOKING_EXPIRED_NOTIFICATION_ID,
+  createToastNotificationWhenCheckoutBookingExpired as sut,
+} from "./createToastNotificationWhenCheckoutBookingExpired";
+
+const aggregateId = "b1cce669-a139-4689-83c8-733549e72b7b";
+
+describe("createToastNotificationWhenCheckoutBookingExpired", () => {
+  const queryBus = jest.fn();
+  const commandBus = jest.fn();
+
+  test("create a toast notification when checkoutBookingExpired occurred", async () => {
+    const checkoutBookingExpiredEvent = checkoutBookingExpired({ aggregateId });
+
+    await sut({ queryBus, commandBus })(checkoutBookingExpiredEvent);
+
+    expect(commandBus).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aggregateId: CHECKOUT_BOOKING_EXPIRED_NOTIFICATION_ID,
+        name: "create_toast_notification",
+        type: NotificationType.TOAST,
+        level: NotificationLevel.ERROR,
+        bodyI18nKey: I18nMessages.CHECKOUT_TOAST_BOOKING_EXPIRED,
+      }),
+    );
+  });
+});