@lookiero/checkout 0.1.1

package/dist/projection/checkout/viewIsCheckoutEnabledByCustomerId.js

@@ -0,0 +1,8 @@
+import { query } from "@lookiero/messaging";
+const VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID = "view_is_checkout_enabled_by_customer_id";
+const viewIsCheckoutEnabledByCustomerId = (payload) => ({
+    ...query({ name: VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID }),
+    ...payload,
+});
+const viewIsCheckoutEnabledByCustomerIdHandler = ({ view }) => async ({ customerId }) => view({ customerId });
+export { VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, viewIsCheckoutEnabledByCustomerId, viewIsCheckoutEnabledByCustomerIdHandler, };

package/dist/projection/uiSetting/viewUiSettingByKey.d.ts

@@ -0,0 +1,28 @@
+import { Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+export interface UiSettingProjection {
+    readonly id: string;
+    readonly key: string;
+    readonly value: unknown;
+}
+export declare const VIEW_UI_SETTING_BY_KEY = "view_ui_setting_by_key";
+interface ViewUiSettingByKeyPayload {
+    readonly key: string;
+}
+interface ViewUiSettingByKey extends Query<typeof VIEW_UI_SETTING_BY_KEY>, ViewUiSettingByKeyPayload {
+}
+interface ViewUiSettingByKeyFunction {
+    (payload: ViewUiSettingByKeyPayload): ViewUiSettingByKey;
+}
+declare type ViewUiSettingByKeyResult = UiSettingProjection | undefined;
+interface UiSettingByKeyViewArgs {
+    readonly key: string;
+}
+export interface UiSettingByKeyView {
+    (args: UiSettingByKeyViewArgs): Promise<ViewUiSettingByKeyResult>;
+}
+interface ViewUiSettingByKeyHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+    readonly view: UiSettingByKeyView;
+}
+export declare const viewUiSettingByKey: ViewUiSettingByKeyFunction;
+export declare const viewUiSettingByKeyHandler: QueryHandlerFunction<ViewUiSettingByKey, ViewUiSettingByKeyResult, ViewUiSettingByKeyHandlerFunctionArgs>;
+export {};

package/dist/projection/uiSetting/viewUiSettingByKey.js

@@ -0,0 +1,7 @@
+import { query } from "@lookiero/messaging";
+export const VIEW_UI_SETTING_BY_KEY = "view_ui_setting_by_key";
+export const viewUiSettingByKey = (payload) => ({
+    ...query({ name: VIEW_UI_SETTING_BY_KEY }),
+    ...payload,
+});
+export const viewUiSettingByKeyHandler = ({ view }) => async ({ key }) => view({ key });

package/jest.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+  preset: "jest-expo",
+  transformIgnorePatterns: [
+    "node_modules/(?!((jest-)?react-native|@react-native(-community)?)|expo(nent)?|@expo(nent)?/.*|@expo-google-fonts/.*|react-navigation|@react-navigation/.*|@unimodules/.*|unimodules|sentry-expo|native-base|react-native-svg|@lookiero/messaging|@lookiero/messaging-react|@lookiero/i18n|@lookiero/i18n-react|react-router-native)",
+  ],
+  coveragePathIgnorePatterns: ["<rootDir>/src/infrastructure/ui/test/"],
+  testPathIgnorePatterns: ["<rootDir>/dist/"],
+  setupFiles: ["<rootDir>/jest.setup.js"],
+};

package/jest.setup.js

@@ -0,0 +1,3 @@
+import mockAsyncStorage from "@react-native-async-storage/async-storage/jest/async-storage-mock";
+
+jest.mock("@react-native-async-storage/async-storage", () => mockAsyncStorage);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@lookiero/checkout",
+  "version": "0.1.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "engines": {
+    "node": ">=14.19.3"
+  },
+  "scripts": {
+    "start": "expo start",
+    "android": "expo start --android",
+    "ios": "expo start --ios",
+    "web": "expo start --web",
+    "build": "tsc -b tsconfig.build.json",
+    "lint": "eslint --fix --cache --cache-location ./node_modules/.cache/.eslintcache --ext ts,tsx .",
+    "format": "prettier --write \"**/*.+(json|css|ts|tsx|md)\"",
+    "test": "jest",
+    "test:coverage": "jest --coverage --coverageReporters=text --detectOpenHandles --forceExit --silent",
+    "publish": "npm publish"
+  },
+  "dependencies": {
+    "@lookiero/i18n": "^0.6.1",
+    "@lookiero/i18n-react": "^0.6.1",
+    "@lookiero/messaging": "^6.2.1",
+    "@lookiero/messaging-react": "^6.2.1",
+    "react-router-dom": "^6.3.0",
+    "react-router-native": "^6.3.0",
+    "uuid": "^9.0.0"
+  },
+  "peerDependencies": {
+    "@lookiero/aurora-next": "^3.0.181",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-native": "^0.69.4",
+    "react-native-web": "^0.18.7"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.9",
+    "@expo/webpack-config": "^0.17.2",
+    "@lookiero/aurora-fonts": "^1.0.6",
+    "@lookiero/aurora-iconfont": "^2.0.37",
+    "@lookiero/aurora-next": "^3.0.181",
+    "@testing-library/react": "^13.3.0",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@testing-library/react-native": "^11.0.0",
+    "@types/jest": "^28.1.7",
+    "@types/react": "~18.0.0",
+    "@types/react-dom": "~18.0.0",
+    "@types/react-native": "~0.69.1",
+    "@types/uuid": "^8.3.4",
+    "eslint": "^8.22.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-react-app": "^7.0.1",
+    "eslint-plugin-flowtype": "^8.0.3",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsx-a11y": "^6.6.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.30.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "expo": "~46.0.8",
+    "expo-status-bar": "~1.4.0",
+    "husky": "^8.0.1",
+    "jest": "^26.6.3",
+    "jest-expo": "^46.0.1",
+    "jest-mock-extended": "^2.0.7",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-native": "^0.69.4",
+    "react-native-web": "^0.18.7",
+    "react-test-renderer": "^18.0.0",
+    "typescript": "^4.6.3"
+  }
+}

package/src/Expo.tsx

@@ -0,0 +1,59 @@
+import { Aurora } from "@lookiero/aurora-next/build/components/primitives/Aurora/Aurora";
+import { Text } from "@lookiero/aurora-next/build/components/primitives/Text/Text";
+import { useFonts } from "expo-font";
+import { activateKeepAwake } from "expo-keep-awake";
+import withExpoRoot from "expo/build/launch/withExpoRoot";
+import { useCallback, useState } from "react";
+import { createRoot } from "react-dom/client";
+import { AppRegistry, Platform, StatusBar } from "react-native";
+// import { bootstrap as checkoutMockBootstrap } from "./infrastructure/delivery/_mock/bootstrap.mock";
+import { bootstrap as checkoutBootstrap } from "./infrastructure/delivery/bootstrap";
+import { root } from "./infrastructure/ui/Root";
+
+const apiUrl = Platform.OS === "web" ? "/local-to-dev" : "https://web2.ps.dev.aws.lookiero.es/checkout/api";
+const authToken =
+  "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOjIwOTUxNjAsImV4cCI6MTY2NTEzMzQxMywiZGlzcGxheU5hbWUiOiJBbGV4YW5kZXIiLCJjb3VudHJ5X2NvZGUiOiJFUyIsImFjY2Vzc1ZpYSI6ImVtYWlsIiwic3Vic2NyaXB0aW9uU3RhcnRpbmdEYXRlIjoiMjAyMC0wOS0wMSIsImltcGVyc29uYXRlZCI6ZmFsc2UsInV1aWQiOiJjZjdjNjQxZi0wZTVjLTQ4NTAtYWUwNy0yNzY3NDdlZGZkMGIiLCJpYXQiOjE2NjI1NDE0MTN9.v17FPhySnvKPjOYiZumdcy-pVQO-F_PHjWSY-tnk2xU";
+
+// const { Component: Messaging } = checkoutMockBootstrap();
+const { Component: Messaging } = checkoutBootstrap({ apiUrl, getAuthToken: () => authToken });
+const Root = root({ Messaging });
+
+const ExpoRoot = () => {
+  const [fontsLoaded] = useFonts({
+    ["Romie-Regular"]: require("@lookiero/aurora-fonts/Romie-Regular.ttf"),
+    ["FoundersGroteskText-Regular"]: require("@lookiero/aurora-fonts/FoundersGroteskText-Regular.ttf"),
+    auroraicons: require("@lookiero/aurora-iconfont/dist/auroraicons.ttf"),
+  });
+
+  const [isAccessible, setIsAccessible] = useState<boolean>();
+  const onNotAccessible = useCallback(() => setIsAccessible(false), []);
+
+  return fontsLoaded ? (
+    <>
+      <Aurora usePortal={false} useStack={false}>
+        {isAccessible === false && <Text heading={true}>Checkout is not accessible!</Text>}
+        <Root locale="es" customerId="606d8c89-d4f2-438b-89a8-906e6526992d" onNotAccessible={onNotAccessible} />
+      </Aurora>
+      <StatusBar />
+    </>
+  ) : null;
+};
+
+if (__DEV__) {
+  activateKeepAwake();
+}
+
+AppRegistry.registerComponent("main", () => withExpoRoot(ExpoRoot));
+
+if ("web" === Platform.OS) {
+  const rootElement = document.getElementById("root") ?? document.getElementById("main");
+
+  if (rootElement) {
+    const rootTag = createRoot(rootElement);
+    const RootComponent = withExpoRoot(ExpoRoot);
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    rootTag.render(<RootComponent />);
+  }
+}

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

@@ -0,0 +1,26 @@
+import { v4 as uuid } from "uuid";
+import {
+  bookSizeReplaceableProductVariantsForCheckoutItem as sut,
+  BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM,
+} from "./bookSizeReplaceableProductVariantsForCheckoutItem";
+
+describe("bookSizeReplaceableProductVariantsForCheckoutItem", () => {
+  it("returns an BookSizeReplaceableProductVariantsForCheckoutItem command", () => {
+    const aggregateId = uuid();
+    const checkoutBooking = {
+      checkoutId: "this-should-be-a-uuid",
+      checkoutItemId: "this-should-be-a-uuid",
+      checkoutBookingId: "this-should-be-a-uuid",
+    };
+
+    const command = sut({ aggregateId, ...checkoutBooking });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.checkoutId).toBe(checkoutBooking.checkoutId);
+    expect(command.checkoutItemId).toBe(checkoutBooking.checkoutItemId);
+    expect(command.checkoutBookingId).toBe(checkoutBooking.checkoutBookingId);
+    expect(command.name).toBe(BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM);
+    expect(typeof command.messageId).toBe("string");
+    expect(typeof command.occurredOn).toBe("number");
+  });
+});

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

@@ -0,0 +1,27 @@
+import { command, Command } from "@lookiero/messaging";
+
+export const BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM =
+  "book_size_replaceable_product_variants_for_checkout_item";
+
+interface BookSizeReplaceableProductVariantsForCheckoutItemPayload {
+  readonly aggregateId: string;
+  readonly checkoutId: string;
+  readonly checkoutItemId: string;
+  readonly checkoutBookingId: string;
+}
+
+export interface BookSizeReplaceableProductVariantsForCheckoutItem
+  extends Command<typeof BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM>,
+    BookSizeReplaceableProductVariantsForCheckoutItemPayload {}
+
+interface BookSizeReplaceableProductVariantsForCheckoutItemFunction {
+  (
+    payload: BookSizeReplaceableProductVariantsForCheckoutItemPayload,
+  ): BookSizeReplaceableProductVariantsForCheckoutItem;
+}
+
+export const bookSizeReplaceableProductVariantsForCheckoutItem: BookSizeReplaceableProductVariantsForCheckoutItemFunction =
+  ({ aggregateId, ...payload }) => ({
+    ...command({ aggregateId, name: BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM }),
+    ...payload,
+  });

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

@@ -0,0 +1,30 @@
+import { DomainEvent, QueryBus } from "@lookiero/messaging";
+import { v4 as uuid } from "uuid";
+import { mock } from "jest-mock-extended";
+import { CHECKOUT_BOOKING_BOOKED } from "./checkoutBookingBooked";
+import { bookSizeReplaceableProductVariantsForCheckoutItemHandler as sut } from "./checkoutBooking";
+import { bookSizeReplaceableProductVariantsForCheckoutItem } from "../command/bookSizeReplaceableProductVariantsForCheckoutItem";
+
+describe("checkoutBooking", () => {
+  const queryBus = mock<QueryBus>();
+
+  it("bookSizeReplaceableProductVariantsForCheckoutItem publishing CheckoutBookingBooked", async () => {
+    const aggregateId = uuid();
+    const checkoutBooking = {
+      checkoutId: "this-should-be-a-uuid",
+      checkoutItemId: "this-should-be-a-uuid",
+      checkoutBookingId: "this-should-be-a-uuid",
+    };
+    const state = { aggregateId, ...checkoutBooking, domainEvents: [] };
+
+    const command = bookSizeReplaceableProductVariantsForCheckoutItem({ aggregateId, ...checkoutBooking });
+
+    const aggregateRoot = await sut({ queryBus })({ aggregateRoot: state, command });
+
+    expect(aggregateRoot.aggregateId).toBe(aggregateId);
+    expect(aggregateRoot.checkoutId).toBe(checkoutBooking.checkoutId);
+    expect(aggregateRoot.checkoutItemId).toBe(checkoutBooking.checkoutItemId);
+    expect(aggregateRoot.checkoutBookingId).toBe(checkoutBooking.checkoutBookingId);
+    expect((aggregateRoot.domainEvents as DomainEvent<string>).name).toBe(CHECKOUT_BOOKING_BOOKED);
+  });
+});

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

@@ -0,0 +1,31 @@
+import { AggregateRoot, CommandHandlerFunction } from "@lookiero/messaging";
+import { BookSizeReplaceableProductVariantsForCheckoutItem } from "../command/bookSizeReplaceableProductVariantsForCheckoutItem";
+import { checkoutBookingBooked } from "./checkoutBookingBooked";
+
+export interface CheckoutBooking extends AggregateRoot {
+  readonly checkoutId: string;
+  readonly checkoutItemId: string;
+  readonly checkoutBookingId: string;
+}
+
+export const bookSizeReplaceableProductVariantsForCheckoutItemHandler: CommandHandlerFunction<
+  BookSizeReplaceableProductVariantsForCheckoutItem,
+  CheckoutBooking
+> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId, checkoutId, checkoutItemId, checkoutBookingId } = command;
+
+    return {
+      ...aggregateRoot,
+      checkoutId,
+      checkoutItemId,
+      checkoutBookingId,
+      domainEvents: checkoutBookingBooked({
+        aggregateId,
+        checkoutId,
+        checkoutItemId,
+        checkoutBookingId,
+      }),
+    };
+  };

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

@@ -0,0 +1,23 @@
+import { v4 as uuid } from "uuid";
+import { checkoutBookingBooked as sut, CHECKOUT_BOOKING_BOOKED } from "./checkoutBookingBooked";
+
+describe("checkoutBookingBooked", () => {
+  it("returns an CheckoutBookingBooked domain event", () => {
+    const aggregateId = uuid();
+    const checkoutBooking = {
+      checkoutId: "this-should-be-a-uuid",
+      checkoutItemId: "this-should-be-a-uuid",
+      checkoutBookingId: "this-should-be-a-uuid",
+    };
+
+    const domainEvent = sut({ aggregateId, ...checkoutBooking });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.checkoutId).toBe(checkoutBooking.checkoutId);
+    expect(domainEvent.checkoutItemId).toBe(checkoutBooking.checkoutItemId);
+    expect(domainEvent.checkoutBookingId).toBe(checkoutBooking.checkoutBookingId);
+    expect(domainEvent.name).toBe(CHECKOUT_BOOKING_BOOKED);
+    expect(typeof domainEvent.messageId).toBe("string");
+    expect(typeof domainEvent.occurredOn).toBe("number");
+  });
+});

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

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

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

@@ -0,0 +1,6 @@
+import { RepositoryGetFunction, RepositorySaveFunction } from "@lookiero/messaging";
+import { CheckoutBooking } from "./checkoutBooking";
+
+export interface CheckoutBookingsGetFunction extends RepositoryGetFunction<CheckoutBooking> {}
+
+export interface CheckoutBookingsSaveFunction extends RepositorySaveFunction<CheckoutBooking> {}

package/src/domain/uiSetting/command/updateUiSetting.test.ts

@@ -0,0 +1,19 @@
+import { v4 as uuid } from "uuid";
+import { updateUiSetting as sut, UPDATE_UI_SETTING } from "./updateUiSetting";
+
+describe("updateUiSetting", () => {
+  it("returns an UpdateUiSetting command", () => {
+    const aggregateId = uuid();
+    const key = "ui_setting_key";
+    const value = "ui_setting_value";
+
+    const command = sut({ aggregateId, key, value });
+
+    expect(command.aggregateId).toBe(aggregateId);
+    expect(command.key).toBe(key);
+    expect(command.value).toBe(value);
+    expect(command.name).toBe(UPDATE_UI_SETTING);
+    expect(typeof command.messageId).toBe("string");
+    expect(typeof command.occurredOn).toBe("number");
+  });
+});

package/src/domain/uiSetting/command/updateUiSetting.ts

@@ -0,0 +1,23 @@
+import { command, Command } from "@lookiero/messaging";
+
+export const UPDATE_UI_SETTING = "update_ui_setting";
+
+interface UpdateUiSettingPayload {
+  readonly aggregateId: string;
+  readonly key: string;
+  readonly value: unknown;
+}
+
+export interface UpdateUiSetting extends Command<typeof UPDATE_UI_SETTING>, UpdateUiSettingPayload {}
+
+interface UpdateUiSettingFunction {
+  (payload: UpdateUiSettingPayload): UpdateUiSetting;
+}
+
+export const updateUiSetting: UpdateUiSettingFunction = ({ aggregateId, ...payload }) => ({
+  ...command({
+    aggregateId,
+    name: UPDATE_UI_SETTING,
+  }),
+  ...payload,
+});

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

@@ -0,0 +1,26 @@
+import { DomainEvent, QueryBus } from "@lookiero/messaging";
+import { v4 as uuid } from "uuid";
+import { mock } from "jest-mock-extended";
+import { UI_SETTING_UPDATED } from "./uiSettingUpdated";
+import { updateUiSettingHandler as sut } from "./uiSetting";
+import { updateUiSetting } from "../command/updateUiSetting";
+
+describe("uiSetting", () => {
+  const queryBus = mock<QueryBus>();
+
+  it("updateUiSetting publishing UiSettingUpdated", async () => {
+    const aggregateId = uuid();
+    const key = "ui_setting_key";
+    const value = "ui_setting_value";
+    const state = { aggregateId, key, value, domainEvents: [] };
+
+    const command = updateUiSetting({ aggregateId, key, value });
+
+    const aggregateRoot = await sut({ queryBus })({ aggregateRoot: state, command });
+
+    expect(aggregateRoot.aggregateId).toBe(aggregateId);
+    expect(aggregateRoot.key).toBe(key);
+    expect(aggregateRoot.value).toBe(value);
+    expect((aggregateRoot.domainEvents as DomainEvent<string>).name).toBe(UI_SETTING_UPDATED);
+  });
+});

package/src/domain/uiSetting/model/uiSetting.ts

@@ -0,0 +1,22 @@
+import { AggregateRoot } from "@lookiero/messaging";
+import { CommandHandlerFunction } from "@lookiero/messaging/domain/model";
+import { UpdateUiSetting } from "../command/updateUiSetting";
+import { uiSettingUpdated } from "./uiSettingUpdated";
+
+export interface UiSetting extends AggregateRoot {
+  readonly key: string;
+  readonly value: unknown;
+}
+
+export const updateUiSettingHandler: CommandHandlerFunction<UpdateUiSetting, UiSetting> =
+  () =>
+  async ({ aggregateRoot, command }) => {
+    const { aggregateId, key, value } = command;
+
+    return {
+      ...aggregateRoot,
+      key,
+      value,
+      domainEvents: uiSettingUpdated({ aggregateId, key }),
+    };
+  };

package/src/domain/uiSetting/model/uiSettingUpdated.test.ts

@@ -0,0 +1,17 @@
+import { v4 as uuid } from "uuid";
+import { uiSettingUpdated as sut, UI_SETTING_UPDATED } from "./uiSettingUpdated";
+
+describe("uiSettingUpdated", () => {
+  it("returns an UiSettingUpdated domain event", () => {
+    const aggregateId = uuid();
+    const key = "ui_setting_key";
+
+    const domainEvent = sut({ aggregateId, key });
+
+    expect(domainEvent.aggregateId).toBe(aggregateId);
+    expect(domainEvent.key).toBe(key);
+    expect(domainEvent.name).toBe(UI_SETTING_UPDATED);
+    expect(typeof domainEvent.messageId).toBe("string");
+    expect(typeof domainEvent.occurredOn).toBe("number");
+  });
+});

package/src/domain/uiSetting/model/uiSettingUpdated.ts

@@ -0,0 +1,19 @@
+import { domainEvent, DomainEvent } from "@lookiero/messaging";
+
+export const UI_SETTING_UPDATED = "ui_setting_updated";
+
+interface UiSettingUpdatedPayload {
+  readonly aggregateId: string;
+  readonly key: string;
+}
+
+export interface UiSettingUpdated extends DomainEvent<typeof UI_SETTING_UPDATED>, UiSettingUpdatedPayload {}
+
+interface UiSettingUpdatedFunction {
+  (payload: UiSettingUpdatedPayload): UiSettingUpdated;
+}
+
+export const uiSettingUpdated: UiSettingUpdatedFunction = ({ aggregateId, key }) => ({
+  ...domainEvent({ aggregateId, name: UI_SETTING_UPDATED }),
+  key,
+});

package/src/domain/uiSetting/model/uiSettings.ts

@@ -0,0 +1,6 @@
+import { RepositoryGetFunction, RepositorySaveFunction } from "@lookiero/messaging";
+import { UiSetting } from "./uiSetting";
+
+export interface UiSettingGetFunction extends RepositoryGetFunction<UiSetting> {}
+
+export interface UiSettingSaveFunction extends RepositorySaveFunction<UiSetting> {}

package/src/index.ts

@@ -0,0 +1,44 @@
+import { FC } from "react";
+import { bootstrap as checkoutBootstrap } from "./infrastructure/delivery/bootstrap";
+import { root, RootProps } from "./infrastructure/ui/Root";
+import {
+  IsCheckoutAccessibleByCustomerIdProjection,
+  viewIsCheckoutAccessibleByCustomerId,
+} from "./projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+
+interface IsCheckoutAccessibleFunctionArgs {
+  readonly customerId: string | undefined;
+}
+
+interface IsCheckoutAccessibleFunction {
+  (args: IsCheckoutAccessibleFunctionArgs): Promise<IsCheckoutAccessibleByCustomerIdProjection>;
+}
+
+interface BootstrapFunctionArgs {
+  readonly getAuthToken: () => string;
+  readonly apiUrl: string;
+}
+
+interface BootstrapFunctionReturn {
+  readonly Root: FC<RootProps>;
+  readonly isCheckoutAccessible: IsCheckoutAccessibleFunction;
+}
+
+interface BootstrapFunction {
+  (args: BootstrapFunctionArgs): BootstrapFunctionReturn;
+}
+
+const bootstrap: BootstrapFunction = ({ apiUrl, getAuthToken }) => {
+  const { Component: Messaging, queryBus } = checkoutBootstrap({ apiUrl, getAuthToken });
+  const Root = root({ Messaging });
+
+  const isCheckoutAccessible: IsCheckoutAccessibleFunction = ({ customerId }) =>
+    queryBus(viewIsCheckoutAccessibleByCustomerId({ customerId }));
+
+  return {
+    Root,
+    isCheckoutAccessible,
+  };
+};
+
+export { bootstrap };

package/src/infrastructure/delivery/_mock/bootstrap.mock.ts

@@ -0,0 +1,38 @@
+import { bootstrap as messagingBootstrap, BuildBootstrapFunctionReturn } from "@lookiero/messaging-react";
+import {
+  CheckoutItemStatus,
+  FirstAvailableCheckoutByCustomerIdView,
+  viewFirstAvailableCheckoutByCustomerIdHandler,
+  VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID,
+} from "../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import {
+  viewIsCheckoutAccessibleByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID,
+} from "../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import {
+  IsCheckoutEnabledByCustomerIdView,
+  viewIsCheckoutEnabledByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID,
+} from "../../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { startedCheckoutWithItems } from "./checkout.mock";
+
+const firstAvailableCheckoutByCustomerIdView: FirstAvailableCheckoutByCustomerIdView = async () =>
+  startedCheckoutWithItems({ status: [CheckoutItemStatus.KEPT, CheckoutItemStatus.INITIAL] });
+const isCheckoutEnabledByCustomerIdView: IsCheckoutEnabledByCustomerIdView = async () => true;
+
+interface BootstrapFunction {
+  (): BuildBootstrapFunctionReturn;
+}
+
+const bootstrap: BootstrapFunction = () =>
+  messagingBootstrap({ id: "Checkout" })
+    .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, {})
+    .build();
+
+export { bootstrap };