@lookiero/checkout 0.3.26 → 0.4.0-beta.0

package/dist/infrastructure/delivery/baseBootstrap.d.ts

@@ -0,0 +1,56 @@
+import { AggregateRoot, RepositoryGetFunction, RepositoryGetFunctionArgs, RepositorySaveFunction, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { BuildBootstrapFunctionReturn } from "@lookiero/messaging-react";
+import { Checkout } from "../../domain/checkout/model/checkout";
+import { CheckoutsGetFunction, CheckoutsSaveFunction } from "../../domain/checkout/model/checkouts";
+import { CheckoutBooking } from "../../domain/checkoutBooking/model/checkoutBooking";
+import { CheckoutBookingsGetFunction, CheckoutBookingsSaveFunction } from "../../domain/checkoutBooking/model/checkoutBookings";
+import { CheckoutItem } from "../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutItemsGetFunction, CheckoutItemsSaveFunction } from "../../domain/checkoutItem/model/checkoutItems";
+import { UiSetting } from "../../domain/uiSetting/model/uiSetting";
+import { UiSettingGetFunction, UiSettingSaveFunction } from "../../domain/uiSetting/model/uiSettings";
+import { BookedSizeChangeProductsVariantsForCheckoutItemView } from "../../projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem";
+import { CheckoutByIdView } from "../../projection/checkout/viewCheckoutById";
+import { FirstAvailableCheckoutByCustomerIdView } from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { FiveItemsDiscountByCustomerIdView } from "../../projection/checkout/viewFiveItemsDiscountByCustomerId";
+import { IsCheckoutEnabledByCustomerIdView } from "../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { CheckoutItemByIdView } from "../../projection/checkoutItem/viewCheckoutItemById";
+import { ReturnQuestionsByCheckoutItemIdView } from "../../projection/returnQuestion/listReturnQuestionsByCheckoutItemId";
+import { UiSettingByKeyView } from "../../projection/uiSetting/viewUiSettingByKey";
+declare const MESSAGING_CONTEXT_ID = "Checkout";
+declare type NeverWhenEmptyRecord<K extends [Record<string, unknown>]> = K extends [Record<string, never>] ? [never?] : K;
+declare type RepositoryDependencies<A extends AggregateRoot, GetFunctionArgs extends RepositoryGetFunctionArgs, SaveFunctionArgs extends RepositorySaveFunctionArgs> = Omit<Parameters<RepositoryGetFunction<A, GetFunctionArgs>>[0] & Parameters<RepositorySaveFunction<A, SaveFunctionArgs>>[0], keyof RepositoryGetFunctionArgs>;
+interface BaseBootstrapFunctionArgs<UiSettingGetFunctionArgs extends RepositoryGetFunctionArgs, UiSettingSaveFunctionArgs extends RepositorySaveFunctionArgs, CheckoutGetFunctionArgs extends RepositoryGetFunctionArgs, CheckoutSaveFunctionArgs extends RepositorySaveFunctionArgs, CheckoutItemGetFunctionArgs extends RepositoryGetFunctionArgs, CheckoutItemSaveFunctionArgs extends RepositorySaveFunctionArgs, CheckoutBookingGetFunctionArgs extends RepositoryGetFunctionArgs, CheckoutBookingSaveFunctionArgs extends RepositorySaveFunctionArgs> {
+    readonly checkoutByIdView: CheckoutByIdView;
+    readonly firstAvailableCheckoutByCustomerIdView: FirstAvailableCheckoutByCustomerIdView;
+    readonly isCheckoutEnabledByCustomerIdView: IsCheckoutEnabledByCustomerIdView;
+    readonly fiveItemsDiscountByCustomerIdView: FiveItemsDiscountByCustomerIdView;
+    readonly uiSettingByKeyView: UiSettingByKeyView;
+    readonly checkoutItemByIdView: CheckoutItemByIdView;
+    readonly returnQuestionsByCheckoutItemIdView: ReturnQuestionsByCheckoutItemIdView;
+    readonly bookedSizeChangeProductsVariantsForCheckoutItemView: BookedSizeChangeProductsVariantsForCheckoutItemView;
+    readonly getUiSetting: UiSettingGetFunction<UiSettingGetFunctionArgs>;
+    readonly saveUiSetting: UiSettingSaveFunction<UiSettingSaveFunctionArgs>;
+    readonly uiSettingsDependencies: NeverWhenEmptyRecord<[
+        RepositoryDependencies<UiSetting, UiSettingGetFunctionArgs, UiSettingSaveFunctionArgs>
+    ]>;
+    readonly getCheckout: CheckoutsGetFunction<CheckoutGetFunctionArgs>;
+    readonly saveCheckout: CheckoutsSaveFunction<CheckoutSaveFunctionArgs>;
+    readonly checkoutsDependencies: NeverWhenEmptyRecord<[
+        RepositoryDependencies<Checkout, CheckoutGetFunctionArgs, CheckoutSaveFunctionArgs>
+    ]>;
+    readonly getCheckoutItem: CheckoutItemsGetFunction<CheckoutItemGetFunctionArgs>;
+    readonly saveCheckoutItem: CheckoutItemsSaveFunction<CheckoutItemSaveFunctionArgs>;
+    readonly checkoutItemsDependencies: NeverWhenEmptyRecord<[
+        RepositoryDependencies<CheckoutItem, CheckoutItemGetFunctionArgs, CheckoutItemSaveFunctionArgs>
+    ]>;
+    readonly getCheckoutBooking: CheckoutBookingsGetFunction<CheckoutBookingGetFunctionArgs>;
+    readonly saveCheckoutBooking: CheckoutBookingsSaveFunction<CheckoutBookingSaveFunctionArgs>;
+    readonly checkoutBookingsDependencies: NeverWhenEmptyRecord<[
+        RepositoryDependencies<CheckoutBooking, CheckoutBookingGetFunctionArgs, CheckoutBookingSaveFunctionArgs>
+    ]>;
+}
+interface BaseBootstrapFunction {
+    <UiSettingGetArgs extends RepositoryGetFunctionArgs, UiSettingSaveArgs extends RepositorySaveFunctionArgs, CheckoutGetFunctionArgs extends RepositoryGetFunctionArgs, CheckoutSaveFunctionArgs extends RepositorySaveFunctionArgs, CheckoutItemGetFunctionArgs extends RepositoryGetFunctionArgs, CheckoutItemSaveFunctionArgs extends RepositorySaveFunctionArgs, CheckoutBookingGetFunctionArgs extends RepositoryGetFunctionArgs, CheckoutBookingSaveFunctionArgs extends RepositorySaveFunctionArgs>(args: BaseBootstrapFunctionArgs<UiSettingGetArgs, UiSettingSaveArgs, CheckoutGetFunctionArgs, CheckoutSaveFunctionArgs, CheckoutItemGetFunctionArgs, CheckoutItemSaveFunctionArgs, CheckoutBookingGetFunctionArgs, CheckoutBookingSaveFunctionArgs>): BuildBootstrapFunctionReturn;
+}
+declare const baseBootstrap: BaseBootstrapFunction;
+export { baseBootstrap, MESSAGING_CONTEXT_ID };

package/dist/infrastructure/delivery/baseBootstrap.js

@@ -0,0 +1,55 @@
+import { bootstrap as messagingBootstrap } from "@lookiero/messaging-react";
+import { START_CHECKOUT } from "../../domain/checkout/command/startCheckout";
+import { startCheckoutHandler } from "../../domain/checkout/model/checkout";
+import { BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM } from "../../domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem";
+import { bookCheckoutBookingForCheckoutItemHandler, } from "../../domain/checkoutBooking/model/checkoutBooking";
+import { KEEP_CHECKOUT_ITEM } from "../../domain/checkoutItem/command/keepCheckoutItem";
+import { REPLACE_CHECKOUT_ITEM } from "../../domain/checkoutItem/command/replaceCheckoutItem";
+import { RETURN_CHECKOUT_ITEM } from "../../domain/checkoutItem/command/returnCheckoutItem";
+import { keepCheckoutItemHandler, replaceCheckoutItemHandler, returnCheckoutItemHandler, } from "../../domain/checkoutItem/model/checkoutItem";
+import { UPDATE_UI_SETTING } from "../../domain/uiSetting/command/updateUiSetting";
+import { updateUiSettingHandler } from "../../domain/uiSetting/model/uiSetting";
+import { viewBookedSizeChangeProductsVariantsForCheckoutItemHandler, VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM, } from "../../projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem";
+import { viewCheckoutByIdHandler, VIEW_CHECKOUT_BY_ID, } from "../../projection/checkout/viewCheckoutById";
+import { viewFirstAvailableCheckoutByCustomerIdHandler, VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, } from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { viewFiveItemsDiscountByCustomerIdHandler, VIEW_FIVE_ITEMS_DISCOUNT_BY_CUSTOMER_ID, } from "../../projection/checkout/viewFiveItemsDiscountByCustomerId";
+import { viewIsCheckoutAccessibleByCustomerIdHandler, VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, } from "../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import { viewIsCheckoutEnabledByCustomerIdHandler, VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, } from "../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { viewCheckoutItemByIdHandler, VIEW_CHECKOUT_ITEM_BY_ID, } from "../../projection/checkoutItem/viewCheckoutItemById";
+import { listReturnQuestionsByCheckoutItemIdHandler, LIST_RETURN_QUESTIONS_BY_CHECKOUT_ITEM_ID, } from "../../projection/returnQuestion/listReturnQuestionsByCheckoutItemId";
+import { viewUiSettingByKeyHandler, VIEW_UI_SETTING_BY_KEY, } from "../../projection/uiSetting/viewUiSettingByKey";
+const MESSAGING_CONTEXT_ID = "Checkout";
+const baseBootstrap = ({ checkoutByIdView, firstAvailableCheckoutByCustomerIdView, isCheckoutEnabledByCustomerIdView, fiveItemsDiscountByCustomerIdView, uiSettingByKeyView, checkoutItemByIdView, returnQuestionsByCheckoutItemIdView, bookedSizeChangeProductsVariantsForCheckoutItemView, getUiSetting, saveUiSetting, uiSettingsDependencies, getCheckout, saveCheckout, checkoutsDependencies, getCheckoutItem, saveCheckoutItem, checkoutItemsDependencies, getCheckoutBooking, saveCheckoutBooking, checkoutBookingsDependencies, }) => messagingBootstrap({ id: MESSAGING_CONTEXT_ID })
+    .query(VIEW_FIVE_ITEMS_DISCOUNT_BY_CUSTOMER_ID, viewFiveItemsDiscountByCustomerIdHandler, {
+    view: fiveItemsDiscountByCustomerIdView,
+})
+    .query(VIEW_CHECKOUT_BY_ID, viewCheckoutByIdHandler, {
+    view: checkoutByIdView,
+})
+    .query(VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, viewFirstAvailableCheckoutByCustomerIdHandler, {
+    view: firstAvailableCheckoutByCustomerIdView,
+})
+    .query(VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, viewIsCheckoutEnabledByCustomerIdHandler, {
+    view: isCheckoutEnabledByCustomerIdView,
+})
+    .query(VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, viewIsCheckoutAccessibleByCustomerIdHandler)
+    .command(START_CHECKOUT, startCheckoutHandler)(getCheckout, saveCheckout, ...checkoutsDependencies)
+    .query(VIEW_CHECKOUT_ITEM_BY_ID, viewCheckoutItemByIdHandler, {
+    view: checkoutItemByIdView,
+})
+    .query(LIST_RETURN_QUESTIONS_BY_CHECKOUT_ITEM_ID, listReturnQuestionsByCheckoutItemIdHandler, {
+    view: returnQuestionsByCheckoutItemIdView,
+})
+    .command(KEEP_CHECKOUT_ITEM, keepCheckoutItemHandler)(getCheckoutItem, saveCheckoutItem, ...checkoutItemsDependencies)
+    .command(RETURN_CHECKOUT_ITEM, returnCheckoutItemHandler)(getCheckoutItem, saveCheckoutItem, ...checkoutItemsDependencies)
+    .command(REPLACE_CHECKOUT_ITEM, replaceCheckoutItemHandler)(getCheckoutItem, saveCheckoutItem, ...checkoutItemsDependencies)
+    .query(VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM, viewBookedSizeChangeProductsVariantsForCheckoutItemHandler, {
+    view: bookedSizeChangeProductsVariantsForCheckoutItemView,
+})
+    .command(BOOK_CHECKOUT_BOOKING_FOR_CHECKOUT_ITEM, bookCheckoutBookingForCheckoutItemHandler)(getCheckoutBooking, saveCheckoutBooking, ...checkoutBookingsDependencies)
+    .query(VIEW_UI_SETTING_BY_KEY, viewUiSettingByKeyHandler, {
+    view: uiSettingByKeyView,
+})
+    .command(UPDATE_UI_SETTING, updateUiSettingHandler)(getUiSetting, saveUiSetting, ...uiSettingsDependencies)
+    .build();
+export { baseBootstrap, MESSAGING_CONTEXT_ID };

package/dist/infrastructure/delivery/bootstrap.d.ts

@@ -0,0 +1,10 @@
+import { BuildBootstrapFunctionReturn } from "@lookiero/messaging-react";
+interface BootstrapFunctionArgs {
+    readonly getAuthToken: () => Promise<string>;
+    readonly apiUrl: string;
+}
+interface BootstrapFunction {
+    (args: BootstrapFunctionArgs): BuildBootstrapFunctionReturn;
+}
+declare const bootstrap: BootstrapFunction;
+export { bootstrap };

package/dist/infrastructure/delivery/bootstrap.js

@@ -0,0 +1,44 @@
+import { getCheckout, saveCheckout } from "../domain/checkout/model/httpCheckouts";
+import { getCheckoutBooking, saveCheckoutBooking } from "../domain/checkoutBooking/model/httpCheckoutBookings";
+import { getCheckoutItem, saveCheckoutItem } from "../domain/checkoutItem/model/httpCheckoutItems";
+import { getUiSetting, saveUiSetting } from "../domain/uiSetting/model/storageUiSettings";
+import { read, write } from "../persistence/asyncStorageStorage";
+import { httpBookedSizeChangeProductsVariantsForCheckoutItemView } from "../projection/bookedSizeChangeProductsVariants/httpBookedSizeChangeProductsVariantsForCheckoutItemView";
+import { httpCheckoutByIdView } from "../projection/checkout/httpCheckoutByIdView";
+import { httpFirstAvailableCheckoutByCustomerIdView } from "../projection/checkout/httpFirstAvailableCheckoutByCustomerIdView";
+import { httpFiveItemsDiscountByCustomerIdView } from "../projection/checkout/httpFiveItemsDiscountByCustomerIdView";
+import { httpIsCheckoutEnabledByCustomerIdView } from "../projection/checkout/httpIsCheckoutEnabledByCustomerIdView";
+import { httpCheckoutItemByIdView } from "../projection/checkoutItem/httpCheckoutItemByIdView";
+import { httpReturnQuestionsByCheckoutItemIdView } from "../projection/returnQuestion/httpReturnQuestionsByCheckoutItemIdView";
+import { storageUiSettingByKeyView } from "../projection/uiSetting/storageUiSettingByKeyView";
+import { baseBootstrap } from "./baseBootstrap";
+import { fetchHttpGet, fetchHttpPost } from "./http/fetchHttpClient";
+const bootstrap = ({ apiUrl, getAuthToken }) => {
+    const httpGet = fetchHttpGet({ apiUrl, getAuthToken });
+    const httpPost = fetchHttpPost({ apiUrl, getAuthToken });
+    return baseBootstrap({
+        checkoutByIdView: httpCheckoutByIdView({ httpPost }),
+        firstAvailableCheckoutByCustomerIdView: httpFirstAvailableCheckoutByCustomerIdView({ httpPost }),
+        isCheckoutEnabledByCustomerIdView: httpIsCheckoutEnabledByCustomerIdView({ httpGet }),
+        fiveItemsDiscountByCustomerIdView: httpFiveItemsDiscountByCustomerIdView({ httpGet }),
+        uiSettingByKeyView: storageUiSettingByKeyView({ read }),
+        checkoutItemByIdView: httpCheckoutItemByIdView({ httpPost }),
+        returnQuestionsByCheckoutItemIdView: httpReturnQuestionsByCheckoutItemIdView({ httpPost }),
+        bookedSizeChangeProductsVariantsForCheckoutItemView: httpBookedSizeChangeProductsVariantsForCheckoutItemView({
+            httpPost,
+        }),
+        getUiSetting,
+        saveUiSetting,
+        uiSettingsDependencies: [{ read, write }],
+        getCheckout,
+        saveCheckout,
+        checkoutsDependencies: [{ httpPost }],
+        getCheckoutItem,
+        saveCheckoutItem,
+        checkoutItemsDependencies: [{ httpPost }],
+        getCheckoutBooking,
+        saveCheckoutBooking,
+        checkoutBookingsDependencies: [{ httpPost }],
+    });
+};
+export { bootstrap };

package/dist/infrastructure/delivery/http/fetchHttpClient.d.ts

@@ -0,0 +1,14 @@
+import { HttpGetFunction, HttpPostFunction } from "./httpClient";
+interface FetchHttpFunctionArgs {
+    readonly apiUrl: string;
+    readonly getAuthToken: () => Promise<string>;
+}
+interface FetchHttpPostFunction {
+    (args: FetchHttpFunctionArgs): HttpPostFunction;
+}
+interface FetchHttpGetFunction {
+    (args: FetchHttpFunctionArgs): HttpGetFunction;
+}
+declare const fetchHttpPost: FetchHttpPostFunction;
+declare const fetchHttpGet: FetchHttpGetFunction;
+export { fetchHttpGet, fetchHttpPost };

package/dist/infrastructure/delivery/http/fetchHttpClient.js

@@ -0,0 +1,20 @@
+const fetchHttpPost = ({ apiUrl, getAuthToken }) => async ({ endpoint, body, signal }) => fetch(`${apiUrl}${endpoint}`, {
+    method: "POST",
+    headers: {
+        ["Content-Type"]: "application/json",
+        authorization: `Bearer ${await getAuthToken()}`,
+    },
+    body: JSON.stringify(body),
+    signal,
+});
+const fetchHttpGet = ({ apiUrl, getAuthToken }) => async ({ endpoint, signal }) => fetch(`${apiUrl}${endpoint}`, {
+    method: "GET",
+    credentials: "include",
+    headers: {
+        Authorization: `Bearer ${await getAuthToken()}`,
+        ["Content-Type"]: "application/json",
+    },
+    referrer: "",
+    signal,
+});
+export { fetchHttpGet, fetchHttpPost };

package/dist/infrastructure/delivery/http/httpClient.d.ts

@@ -0,0 +1,16 @@
+interface HttpGetFunctionArgs {
+    readonly endpoint: string;
+    readonly signal?: AbortSignal;
+}
+interface HttpGetFunction {
+    (args: HttpGetFunctionArgs): Promise<Response>;
+}
+interface HttpPostFunctionArgs {
+    readonly endpoint: string;
+    readonly body: Record<string, unknown>;
+    readonly signal?: AbortSignal;
+}
+interface HttpPostFunction {
+    (args: HttpPostFunctionArgs): Promise<Response>;
+}
+export type { HttpGetFunction, HttpPostFunction };

package/dist/infrastructure/delivery/http/httpClient.js

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

package/dist/infrastructure/delivery/mock/checkoutBookingDataSource.d.ts

@@ -0,0 +1,14 @@
+import { CheckoutBookingProjection } from "../../../projection/checkoutBooking/checkoutBooking";
+interface CheckoutBookingDataSourceFunctionArgs {
+    readonly data: CheckoutBookingProjection;
+}
+interface CheckoutBookingDataSource {
+    readonly getCheckoutBooking: (id: string) => CheckoutBookingProjection | undefined;
+    readonly saveCheckoutBooking: (checkoutBooking: CheckoutBookingProjection) => void;
+}
+interface CheckoutBookingDataSourceFunction {
+    (args: CheckoutBookingDataSourceFunctionArgs): CheckoutBookingDataSource;
+}
+declare const checkoutBookingDataSource: CheckoutBookingDataSourceFunction;
+export type { CheckoutBookingDataSource };
+export { checkoutBookingDataSource };

package/dist/infrastructure/delivery/mock/checkoutBookingDataSource.js

@@ -0,0 +1,12 @@
+const checkoutBookingDataSource = ({ data: initialData }) => {
+    let data = initialData;
+    const getCheckoutBooking = () => data;
+    const saveCheckoutBooking = (checkoutBooking) => {
+        data = checkoutBooking;
+    };
+    return {
+        getCheckoutBooking,
+        saveCheckoutBooking,
+    };
+};
+export { checkoutBookingDataSource };

package/dist/infrastructure/delivery/mock/checkoutDataSource.d.ts

@@ -0,0 +1,17 @@
+import { CheckoutProjection } from "../../../projection/checkout/checkout";
+import { CheckoutItemProjection } from "../../../projection/checkoutItem/checkoutItem";
+interface CheckoutDataSourceFunctionArgs {
+    readonly data: CheckoutProjection;
+}
+interface CheckoutDataSource {
+    readonly getCheckout: () => CheckoutProjection;
+    readonly saveCheckout: (checkout: CheckoutProjection) => void;
+    readonly getCheckoutItem: (id: string) => CheckoutItemProjection | null;
+    readonly saveCheckoutItem: (checkoutItem: CheckoutItemProjection) => void;
+}
+interface CheckoutDataSourceFunction {
+    (args: CheckoutDataSourceFunctionArgs): CheckoutDataSource;
+}
+declare const checkoutDataSource: CheckoutDataSourceFunction;
+export type { CheckoutDataSource };
+export { checkoutDataSource };

package/dist/infrastructure/delivery/mock/checkoutDataSource.js

@@ -0,0 +1,18 @@
+const checkoutDataSource = ({ data: initialData }) => {
+    let data = initialData;
+    const getCheckout = () => data;
+    const saveCheckout = (checkout) => {
+        data = checkout;
+    };
+    const getCheckoutItem = (id) => data.items.find((item) => item.id === id) || null;
+    const saveCheckoutItem = (checkoutItem) => {
+        data = { ...data, items: data.items.map((item) => (item.id === checkoutItem.id ? checkoutItem : item)) };
+    };
+    return {
+        getCheckout,
+        saveCheckout,
+        getCheckoutItem,
+        saveCheckoutItem,
+    };
+};
+export { checkoutDataSource };

package/dist/infrastructure/delivery/mock/dataSourceCheckoutBookings.d.ts

@@ -0,0 +1,14 @@
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { CheckoutBooking } from "../../../domain/checkoutBooking/model/checkoutBooking";
+import { CheckoutBookingsGetFunction, CheckoutBookingsSaveFunction } from "../../../domain/checkoutBooking/model/checkoutBookings";
+import { CheckoutBookingProjection } from "../../../projection/checkoutBooking/checkoutBooking";
+import { CheckoutBookingDataSource } from "./checkoutBookingDataSource";
+declare const toCheckoutBookingProjection: (checkoutBooking: CheckoutBooking) => CheckoutBookingProjection;
+declare const getCheckoutBooking: CheckoutBookingsGetFunction<RepositoryGetFunctionArgs>;
+interface DataSourceCheckoutItemsSaveFunctionArgs extends RepositorySaveFunctionArgs {
+    readonly dataSource: CheckoutBookingDataSource;
+}
+interface DataSourceCheckoutItemsSaveFunction extends CheckoutBookingsSaveFunction<DataSourceCheckoutItemsSaveFunctionArgs> {
+}
+declare const saveCheckoutBooking: DataSourceCheckoutItemsSaveFunction;
+export { getCheckoutBooking, saveCheckoutBooking, toCheckoutBookingProjection };

package/dist/infrastructure/delivery/mock/dataSourceCheckoutBookings.js

@@ -0,0 +1,21 @@
+import invariant from "tiny-invariant";
+import { viewBookedSizeChangeProductsVariantsForCheckoutItem, } from "../../../projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem";
+const toCheckoutBookingDomain = (checkoutBooking) => {
+    invariant(checkoutBooking, "No checkoutBooking found!");
+    return {
+        aggregateId: checkoutBooking.id,
+        checkoutId: checkoutBooking.checkoutId,
+        checkoutItemIds: [checkoutBooking.checkoutItemId],
+        domainEvents: [],
+    };
+};
+const toCheckoutBookingProjection = (checkoutBooking) => ({
+    id: checkoutBooking.aggregateId,
+    checkoutId: checkoutBooking.checkoutId,
+    checkoutItemIds: checkoutBooking.checkoutItemIds,
+});
+const getCheckoutBooking = ({ queryBus }) => async (aggregateId) => toCheckoutBookingDomain(await queryBus(viewBookedSizeChangeProductsVariantsForCheckoutItem({ checkoutItemId: aggregateId })));
+const saveCheckoutBooking = ({ dataSource }) => async (aggregateRoot) => {
+    dataSource.saveCheckoutBooking(toCheckoutBookingProjection(aggregateRoot));
+};
+export { getCheckoutBooking, saveCheckoutBooking, toCheckoutBookingProjection };

package/dist/infrastructure/delivery/mock/dataSourceCheckoutItems.d.ts

@@ -0,0 +1,14 @@
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { CheckoutItem } from "../../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutItemsGetFunction, CheckoutItemsSaveFunction } from "../../../domain/checkoutItem/model/checkoutItems";
+import { CheckoutItemProjection } from "../../../projection/checkoutItem/checkoutItem";
+import { CheckoutDataSource } from "./checkoutDataSource";
+declare const toCheckoutItemProjection: (checkoutItem: CheckoutItem) => CheckoutItemProjection;
+declare const getCheckoutItem: CheckoutItemsGetFunction<RepositoryGetFunctionArgs>;
+interface DataSourceCheckoutItemsSaveFunctionArgs extends RepositorySaveFunctionArgs {
+    readonly dataSource: CheckoutDataSource;
+}
+interface DataSourceCheckoutItemsSaveFunction extends CheckoutItemsSaveFunction<DataSourceCheckoutItemsSaveFunctionArgs> {
+}
+declare const saveCheckoutItem: DataSourceCheckoutItemsSaveFunction;
+export { getCheckoutItem, saveCheckoutItem, toCheckoutItemProjection };

package/dist/infrastructure/delivery/mock/dataSourceCheckoutItems.js

@@ -0,0 +1,25 @@
+import invariant from "tiny-invariant";
+import { viewCheckoutItemById, } from "../../../projection/checkoutItem/viewCheckoutItemById";
+const toCheckoutItemProjection = (checkoutItem) => ({
+    id: checkoutItem.aggregateId,
+    status: checkoutItem.status,
+    productVariant: {},
+    feedback: {},
+    price: checkoutItem.price,
+});
+const toCheckoutItemDomain = (checkoutItem) => {
+    invariant(checkoutItem, "No checkoutItem found!");
+    return {
+        aggregateId: checkoutItem.id,
+        id: checkoutItem.id,
+        status: checkoutItem.status,
+        price: checkoutItem.price,
+        feedbacks: checkoutItem.feedback,
+        domainEvents: [],
+    };
+};
+const getCheckoutItem = ({ queryBus }) => async (aggregateId) => toCheckoutItemDomain(await queryBus(viewCheckoutItemById({ checkoutItemId: aggregateId })));
+const saveCheckoutItem = ({ dataSource }) => async (aggregateRoot) => {
+    dataSource.saveCheckoutItem(toCheckoutItemProjection(aggregateRoot));
+};
+export { getCheckoutItem, saveCheckoutItem, toCheckoutItemProjection };

package/dist/infrastructure/delivery/mock/dataSourceCheckouts.d.ts

@@ -0,0 +1,11 @@
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { CheckoutsGetFunction, CheckoutsSaveFunction } from "../../../domain/checkout/model/checkouts";
+import { CheckoutDataSource } from "./checkoutDataSource";
+declare const getCheckout: CheckoutsGetFunction<RepositoryGetFunctionArgs>;
+interface DataSourceCheckoutsSaveFunctionArgs extends RepositorySaveFunctionArgs {
+    readonly dataSource: CheckoutDataSource;
+}
+interface DataSourceCheckoutsSaveFunction extends CheckoutsSaveFunction<DataSourceCheckoutsSaveFunctionArgs> {
+}
+declare const saveCheckout: DataSourceCheckoutsSaveFunction;
+export { getCheckout, saveCheckout };

package/dist/infrastructure/delivery/mock/dataSourceCheckouts.js

@@ -0,0 +1,27 @@
+import invariant from "tiny-invariant";
+import { viewCheckoutById, } from "../../../projection/checkout/viewCheckoutById";
+const toCheckoutDomain = (checkout) => {
+    invariant(checkout, "No checkout found!");
+    return {
+        id: checkout.id,
+        status: checkout.status,
+        customerId: checkout.customerId,
+        boxId: checkout.boxId,
+        bookingId: checkout.bookingId,
+        expiresOn: checkout.expiresOn,
+        aggregateId: checkout.id,
+        domainEvents: [],
+    };
+};
+const toCheckoutProjection = (checkout) => ({
+    id: checkout.aggregateId,
+    status: checkout.status,
+    customerId: checkout.customerId,
+    boxId: checkout.boxId,
+    bookingId: checkout.bookingId,
+    expiresOn: checkout.expiresOn,
+    items: [],
+});
+const getCheckout = ({ queryBus }) => async (aggregateId) => toCheckoutDomain(await queryBus(viewCheckoutById({ checkoutId: aggregateId })));
+const saveCheckout = ({ dataSource }) => async (aggregateRoot) => dataSource.saveCheckout(toCheckoutProjection(aggregateRoot));
+export { getCheckout, saveCheckout };

package/dist/infrastructure/domain/checkout/model/httpCheckouts.d.ts

@@ -0,0 +1,16 @@
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { CheckoutsGetFunction, CheckoutsSaveFunction } from "../../../../domain/checkout/model/checkouts";
+import { HttpPostFunction } from "../../../delivery/http/httpClient";
+interface HttpCheckoutsGetFunctionArgs extends RepositoryGetFunctionArgs {
+}
+interface HttpCheckoutsGetFunction extends CheckoutsGetFunction<HttpCheckoutsGetFunctionArgs> {
+}
+declare const getCheckout: HttpCheckoutsGetFunction;
+interface HttpCheckoutsSaveFunctionArgs extends RepositorySaveFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpCheckoutsSaveFunction extends CheckoutsSaveFunction<HttpCheckoutsSaveFunctionArgs> {
+}
+declare const saveCheckout: HttpCheckoutsSaveFunction;
+export type { HttpCheckoutsSaveFunction };
+export { getCheckout, saveCheckout };

package/dist/infrastructure/domain/checkout/model/httpCheckouts.js

@@ -0,0 +1,19 @@
+import invariant from "tiny-invariant";
+import { viewCheckoutById, } from "../../../../projection/checkout/viewCheckoutById";
+import { httpCheckoutsStart } from "./httpCheckoutsStart";
+const toDomain = (checkout) => {
+    invariant(checkout, "No checkout found!");
+    return {
+        id: checkout.id,
+        status: checkout.status,
+        customerId: checkout.customerId,
+        boxId: checkout.boxId,
+        bookingId: checkout.bookingId,
+        expiresOn: checkout.expiresOn,
+        aggregateId: checkout.id,
+        domainEvents: [],
+    };
+};
+const getCheckout = ({ queryBus }) => async (aggregateId) => toDomain(await queryBus(viewCheckoutById({ checkoutId: aggregateId })));
+const saveCheckout = ({ httpPost }) => async (aggregateRoot) => await httpCheckoutsStart({ httpPost })(aggregateRoot);
+export { getCheckout, saveCheckout };

package/dist/infrastructure/domain/checkout/model/httpCheckoutsStart.d.ts

@@ -0,0 +1,5 @@
+import { HttpCheckoutsSaveFunction } from "./httpCheckouts";
+interface HttpCheckoutsStartFunction extends HttpCheckoutsSaveFunction {
+}
+declare const httpCheckoutsStart: HttpCheckoutsStartFunction;
+export { httpCheckoutsStart };

package/dist/infrastructure/domain/checkout/model/httpCheckoutsStart.js

@@ -0,0 +1,13 @@
+import { CHECKOUT_STARTED } from "../../../../domain/checkout/model/checkoutStarted";
+const isCheckoutStarted = (event) => event.name === CHECKOUT_STARTED;
+const httpCheckoutsStart = ({ httpPost }) => async ({ aggregateId, domainEvents }) => {
+    const checkoutStarted = domainEvents.find(isCheckoutStarted);
+    if (!checkoutStarted) {
+        return;
+    }
+    await httpPost({
+        endpoint: "/start-checkout",
+        body: { checkoutId: aggregateId },
+    });
+};
+export { httpCheckoutsStart };

package/dist/infrastructure/domain/checkout/react/useStartCheckout.d.ts

@@ -0,0 +1,13 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface StartCheckoutFunction {
+    (): Promise<void>;
+}
+interface UseStartCheckoutArgs {
+    readonly checkoutId: string;
+}
+declare type UseStartCheckoutResult = [start: StartCheckoutFunction, status: CommandStatus];
+interface UseStartCheckout {
+    (args: UseStartCheckoutArgs): UseStartCheckoutResult;
+}
+declare const useStartCheckout: UseStartCheckout;
+export { useStartCheckout };

package/dist/infrastructure/domain/checkout/react/useStartCheckout.js

@@ -0,0 +1,10 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { startCheckout } from "../../../../domain/checkout/command/startCheckout";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const useStartCheckout = ({ checkoutId }) => {
+    const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+    const start = useCallback(() => commandBus(startCheckout({ aggregateId: checkoutId })), [checkoutId, commandBus]);
+    return [start, status];
+};
+export { useStartCheckout };

package/dist/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.d.ts

@@ -0,0 +1,16 @@
+import { RepositoryGetFunctionArgs, RepositorySaveFunctionArgs } from "@lookiero/messaging";
+import { CheckoutBookingsGetFunction, CheckoutBookingsSaveFunction } from "../../../../domain/checkoutBooking/model/checkoutBookings";
+import { HttpPostFunction } from "../../../delivery/http/httpClient";
+interface HttpCheckoutBookingsGetFunctionArgs extends RepositoryGetFunctionArgs {
+}
+interface HttpCheckoutBookingsGetFunction extends CheckoutBookingsGetFunction<HttpCheckoutBookingsGetFunctionArgs> {
+}
+declare const getCheckoutBooking: HttpCheckoutBookingsGetFunction;
+interface HttpCheckoutBookingsSaveFunctionArgs extends RepositorySaveFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpCheckoutBookingsSaveFunction extends CheckoutBookingsSaveFunction<HttpCheckoutBookingsSaveFunctionArgs> {
+}
+declare const saveCheckoutBooking: HttpCheckoutBookingsSaveFunction;
+export type { HttpCheckoutBookingsSaveFunction };
+export { getCheckoutBooking, saveCheckoutBooking };

package/dist/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.js

@@ -0,0 +1,15 @@
+import invariant from "tiny-invariant";
+import { viewCheckoutBookingById, } from "../../../../projection/checkoutBooking/viewCheckoutBookingById";
+import { httpCheckoutBookingsBook } from "./httpCheckoutBookingsBook";
+const toDomain = (checkoutBooking) => {
+    invariant(checkoutBooking, "No checkout booking found!");
+    return {
+        checkoutId: checkoutBooking.checkoutId,
+        checkoutItemIds: checkoutBooking.checkoutItemIds,
+        aggregateId: checkoutBooking.id,
+        domainEvents: [],
+    };
+};
+const getCheckoutBooking = ({ queryBus }) => async (aggregateId) => toDomain(await queryBus(viewCheckoutBookingById({ checkoutBookingId: aggregateId })));
+const saveCheckoutBooking = ({ httpPost }) => async (aggregateRoot) => await httpCheckoutBookingsBook({ httpPost })(aggregateRoot);
+export { getCheckoutBooking, saveCheckoutBooking };

package/dist/infrastructure/domain/checkoutBooking/model/httpCheckoutBookingsBook.d.ts

@@ -0,0 +1,5 @@
+import { HttpCheckoutBookingsSaveFunction } from "./httpCheckoutBookings";
+interface HttpCheckoutBookingsBookFunction extends HttpCheckoutBookingsSaveFunction {
+}
+declare const httpCheckoutBookingsBook: HttpCheckoutBookingsBookFunction;
+export { httpCheckoutBookingsBook };

package/dist/infrastructure/domain/checkoutBooking/model/httpCheckoutBookingsBook.js

@@ -0,0 +1,18 @@
+import { CHECKOUT_BOOKING_BOOKED, } from "../../../../domain/checkoutBooking/model/checkoutBookingBooked";
+const isCheckoutBookingBooked = (event) => event.name === CHECKOUT_BOOKING_BOOKED;
+const httpCheckoutBookingsBook = ({ httpPost }) => async ({ aggregateId, checkoutId, domainEvents }) => {
+    const checkoutBookingBooked = domainEvents.find(isCheckoutBookingBooked);
+    if (!checkoutBookingBooked) {
+        return;
+    }
+    const { checkoutItemId } = checkoutBookingBooked;
+    await httpPost({
+        endpoint: "/book-size-change-product-variants-for-checkout-item",
+        body: {
+            checkoutId,
+            checkoutItemId,
+            checkoutBookingId: aggregateId,
+        },
+    });
+};
+export { httpCheckoutBookingsBook };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckouBookingForCheckoutItem.d.ts

@@ -0,0 +1,15 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface BookFunction {
+    (): Promise<void>;
+}
+declare type UseBookCheckouBookingForCheckoutItem = [book: BookFunction, status: CommandStatus];
+interface UseBookCheckouBookingForCheckoutItemFunctionArgs {
+    readonly checkoutId: string;
+    readonly checkoutItemId: string;
+    readonly checkoutBookingId: string | undefined;
+}
+interface UseBookCheckouBookingForCheckoutItemFunction {
+    (args: UseBookCheckouBookingForCheckoutItemFunctionArgs): UseBookCheckouBookingForCheckoutItem;
+}
+declare const useBookCheckouBookingForCheckoutItem: UseBookCheckouBookingForCheckoutItemFunction;
+export { useBookCheckouBookingForCheckoutItem };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckouBookingForCheckoutItem.js

@@ -0,0 +1,15 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { bookCheckoutBookingForCheckoutItem } from "../../../../domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const useBookCheckouBookingForCheckoutItem = ({ checkoutId, checkoutItemId, checkoutBookingId, }) => {
+    const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+    const book = useCallback(() => commandBus(bookCheckoutBookingForCheckoutItem({
+        aggregateId: checkoutBookingId || uuid(),
+        checkoutId,
+        checkoutItemId,
+    })), [checkoutBookingId, checkoutId, checkoutItemId, commandBus]);
+    return [book, status];
+};
+export { useBookCheckouBookingForCheckoutItem };

package/dist/infrastructure/domain/checkoutBooking/react/useBookSizeReplaceableProductVariantsForCheckoutItem.d.ts

@@ -0,0 +1,15 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface BookFunction {
+    (): Promise<void>;
+}
+declare type UseBookSizeReplaceableProductVariantsForCheckoutItem = [book: BookFunction, status: CommandStatus];
+interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs {
+    readonly checkoutId: string;
+    readonly checkoutItemId: string;
+    readonly checkoutBookingId: string;
+}
+interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunction {
+    (args: UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs): UseBookSizeReplaceableProductVariantsForCheckoutItem;
+}
+declare const useBookSizeReplaceableProductVariantsForCheckoutItem: UseBookSizeReplaceableProductVariantsForCheckoutItemFunction;
+export { useBookSizeReplaceableProductVariantsForCheckoutItem };