@lookiero/checkout 0.1.1

package/src/projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem.ts

@@ -0,0 +1,85 @@
+import { query, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+
+interface SizeFormat {
+  readonly format: string;
+  readonly length?: string;
+  readonly size: string;
+}
+
+interface Size {
+  readonly id: string;
+  readonly europe: SizeFormat;
+  readonly it: SizeFormat;
+  readonly lookiero: SizeFormat;
+  readonly uk: SizeFormat;
+}
+
+interface ProductVariant {
+  readonly id: string;
+  readonly size: Size;
+}
+
+interface BookedSizeReplaceableProductVariantsProjection {
+  readonly booking: string | null;
+  readonly productVariants: ProductVariant[];
+}
+
+const VIEW_BOOKED_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM =
+  "view_booked_size_replaceable_product_variants_for_checkout_item";
+
+interface ViewBookedSizeReplaceableProductVariantsForCheckoutItemPayload {
+  readonly checkoutItemId: string;
+}
+
+interface ViewBookedSizeReplaceableProductVariantsForCheckoutItem
+  extends Query<typeof VIEW_BOOKED_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM>,
+    ViewBookedSizeReplaceableProductVariantsForCheckoutItemPayload {}
+
+interface ViewBookedSizeReplaceableProductVariantsForCheckoutItemFunction {
+  (
+    payload: ViewBookedSizeReplaceableProductVariantsForCheckoutItemPayload,
+  ): ViewBookedSizeReplaceableProductVariantsForCheckoutItem;
+}
+
+const viewBookedSizeReplaceableProductVariantsForCheckoutItem: ViewBookedSizeReplaceableProductVariantsForCheckoutItemFunction =
+  (payload) => ({
+    ...query({ name: VIEW_BOOKED_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM }),
+    ...payload,
+  });
+
+type ViewBookedSizeReplaceableProductVariantsForCheckoutItemResult =
+  | BookedSizeReplaceableProductVariantsProjection
+  | undefined;
+
+interface BookedSizeReplaceableProductVariantsForCheckoutItemViewArgs {
+  readonly checkoutItemId: string;
+}
+
+interface BookedSizeReplaceableProductVariantsForCheckoutItemView {
+  (
+    args: BookedSizeReplaceableProductVariantsForCheckoutItemViewArgs,
+  ): Promise<ViewBookedSizeReplaceableProductVariantsForCheckoutItemResult>;
+}
+
+interface ViewBookedSizeReplaceableProductVariantsForCheckoutItemHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+  readonly view: BookedSizeReplaceableProductVariantsForCheckoutItemView;
+}
+
+const viewBookedSizeReplaceableProductVariantsForCheckoutItemHandler: QueryHandlerFunction<
+  ViewBookedSizeReplaceableProductVariantsForCheckoutItem,
+  ViewBookedSizeReplaceableProductVariantsForCheckoutItemResult,
+  ViewBookedSizeReplaceableProductVariantsForCheckoutItemHandlerFunctionArgs
+> =
+  ({ view }) =>
+  async ({ checkoutItemId }) =>
+    view({ checkoutItemId });
+
+export {
+  Size,
+  ProductVariant,
+  BookedSizeReplaceableProductVariantsProjection,
+  VIEW_BOOKED_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM,
+  viewBookedSizeReplaceableProductVariantsForCheckoutItem,
+  BookedSizeReplaceableProductVariantsForCheckoutItemView,
+  viewBookedSizeReplaceableProductVariantsForCheckoutItemHandler,
+};

package/src/projection/checkout/viewFirstAvailableCheckoutByCustomerId.test.ts

@@ -0,0 +1,22 @@
+import { QueryBus } from "@lookiero/messaging";
+import { mock } from "jest-mock-extended";
+import {
+  CheckoutProjection,
+  viewFirstAvailableCheckoutByCustomerId,
+  viewFirstAvailableCheckoutByCustomerIdHandler as sut,
+} from "./viewFirstAvailableCheckoutByCustomerId";
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutProjection: CheckoutProjection = { id: "75574065-5838-42de-9924-c712f7854347" } as CheckoutProjection;
+const queryBus = mock<QueryBus>();
+
+describe("viewFirstAvailableCheckoutByCustomerId", () => {
+  it("returns the first available checkout by customer id", async () => {
+    const query = viewFirstAvailableCheckoutByCustomerId({ customerId });
+    const view = jest.fn(() => Promise.resolve(checkoutProjection));
+
+    const checkoutProjectionResult = await sut({ view, queryBus })(query);
+
+    expect(checkoutProjectionResult).toBe(checkoutProjection);
+  });
+});

package/src/projection/checkout/viewFirstAvailableCheckoutByCustomerId.ts

@@ -0,0 +1,149 @@
+import { query, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+
+enum MediaPerspective {
+  BACK = "BACK",
+  BOTTOM_UP = "BOTTOM_UP",
+  COLLAGE = "COLLAGE",
+  DETAIL = "DETAIL",
+  FLAT_BACK = "FLAT_BACK",
+  FRONT = "FRONT",
+  FRONT_FAR = "FRONT_FAR",
+  LABEL = "LABEL",
+  MAIN = "MAIN",
+  MAIN_TRANSPARENT = "MAIN_TRANSPARENT",
+  OTHER = "OTHER",
+  SIDE = "SIDE",
+}
+
+interface MediaProjection {
+  readonly id: string;
+  readonly url: string;
+  readonly perspective: MediaPerspective;
+}
+
+enum Currency {
+  EUR = "EUR",
+  GBP = "GBP",
+}
+
+interface PriceProjection {
+  readonly amount: number;
+  readonly currency: Currency;
+  readonly discountedPrice?: {
+    readonly amount: number;
+    readonly percentage: number;
+  };
+}
+
+interface SizeProjection {
+  readonly id: string;
+  readonly lookiero: string;
+  readonly uk: string;
+  readonly it: string;
+  readonly europe: string;
+  readonly unique: boolean;
+  readonly visualOrder?: number;
+}
+
+interface ColorProjection {
+  readonly id: string;
+  readonly label: string;
+}
+
+interface CheckoutItemProductVariantProjection {
+  readonly id: string;
+  readonly media: MediaProjection[];
+  readonly brand: string;
+  readonly name: string;
+  readonly price: PriceProjection;
+  readonly size: SizeProjection;
+  readonly color: ColorProjection;
+}
+
+enum CheckoutItemStatus {
+  INITIAL = "INITIAL",
+  KEPT = "KEPT",
+  RETURNED = "RETURNED",
+  REPLACED = "REPLACED",
+  EXPIRED = "EXPIRED",
+}
+
+interface CheckoutItemProjection {
+  readonly id: string;
+  readonly status: CheckoutItemStatus;
+  readonly replacedFor?: string;
+  readonly productVariant: CheckoutItemProductVariantProjection;
+  // readonly feedbacks: Feedback[];
+}
+
+enum CheckoutStatus {
+  AVAILABLE = "AVAILABLE",
+  NOTIFIED = "NOTIFIED",
+  STARTED = "STARTED",
+  COMPLETED = "COMPLETED",
+}
+
+interface CheckoutProjection {
+  readonly id: string;
+  readonly customerId: string;
+  readonly boxId: string;
+  readonly bookingId: string;
+  readonly status: CheckoutStatus;
+  readonly expiresOn: Date;
+  readonly items: CheckoutItemProjection[];
+}
+
+const VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID = "view_first_available_checkout_by_customer_id";
+
+interface ViewFirstAvailableCheckoutByCustomerIdPayload {
+  readonly customerId: string;
+}
+
+interface ViewFirstAvailableCheckoutByCustomerId
+  extends Query<typeof VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID>,
+    ViewFirstAvailableCheckoutByCustomerIdPayload {}
+
+interface ViewFirstAvailableCheckoutByCustomerIdFunction {
+  (payload: ViewFirstAvailableCheckoutByCustomerIdPayload): ViewFirstAvailableCheckoutByCustomerId;
+}
+
+const viewFirstAvailableCheckoutByCustomerId: ViewFirstAvailableCheckoutByCustomerIdFunction = (payload) => ({
+  ...query({ name: VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID }),
+  ...payload,
+});
+
+type ViewFirstAvailableCheckoutByCustomerIdResult = CheckoutProjection | undefined;
+
+interface FirstAvailableCheckoutByCustomerIdViewArgs {
+  readonly customerId: string;
+}
+
+interface FirstAvailableCheckoutByCustomerIdView {
+  (args: FirstAvailableCheckoutByCustomerIdViewArgs): Promise<ViewFirstAvailableCheckoutByCustomerIdResult>;
+}
+
+interface ViewFirstAvailableCheckoutByCustomerIdHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+  readonly view: FirstAvailableCheckoutByCustomerIdView;
+}
+
+const viewFirstAvailableCheckoutByCustomerIdHandler: QueryHandlerFunction<
+  ViewFirstAvailableCheckoutByCustomerId,
+  ViewFirstAvailableCheckoutByCustomerIdResult,
+  ViewFirstAvailableCheckoutByCustomerIdHandlerFunctionArgs
+> =
+  ({ view }) =>
+  async ({ customerId }) =>
+    view({ customerId });
+
+export {
+  CheckoutProjection,
+  CheckoutStatus,
+  CheckoutItemProjection,
+  CheckoutItemStatus,
+  MediaPerspective,
+  Currency,
+  VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID,
+  viewFirstAvailableCheckoutByCustomerId,
+  FirstAvailableCheckoutByCustomerIdView,
+  viewFirstAvailableCheckoutByCustomerIdHandler,
+};

package/src/projection/checkout/viewIsCheckoutAccessibleByCustomerId.test.ts

@@ -0,0 +1,54 @@
+import { bootstrap } from "@lookiero/messaging";
+import {
+  CheckoutProjection,
+  viewFirstAvailableCheckoutByCustomerIdHandler,
+  VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID,
+} from "./viewFirstAvailableCheckoutByCustomerId";
+import {
+  viewIsCheckoutAccessibleByCustomerId,
+  viewIsCheckoutAccessibleByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID,
+} from "./viewIsCheckoutAccessibleByCustomerId";
+import {
+  viewIsCheckoutEnabledByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID,
+} from "./viewIsCheckoutEnabledByCustomerId";
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutProjection: CheckoutProjection = { id: "75574065-5838-42de-9924-c712f7854347" };
+const firstAvailableCheckoutByCustomerIdViewMock = jest.fn();
+const isCheckoutEnabledByCustomerIdViewMock = jest.fn();
+
+const { queryBus } = bootstrap()
+  .query(VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, viewFirstAvailableCheckoutByCustomerIdHandler, {
+    view: firstAvailableCheckoutByCustomerIdViewMock,
+  })
+  .query(VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, viewIsCheckoutEnabledByCustomerIdHandler, {
+    view: isCheckoutEnabledByCustomerIdViewMock,
+  })
+  .query(VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, viewIsCheckoutAccessibleByCustomerIdHandler, {})
+  .build();
+
+// expectedResult, customerId, CheckoutProjection, isCheckoutEnabled
+type Scenarios = [boolean, string | undefined, CheckoutProjection | undefined, boolean][];
+const scenarios: Scenarios = [
+  [false, undefined, checkoutProjection, true],
+  [false, customerId, undefined, true],
+  [false, customerId, checkoutProjection, false],
+  [true, customerId, checkoutProjection, true],
+];
+
+describe("viewIsCheckoutAccessibleByCustomerId", () => {
+  test.each(scenarios)(
+    "Returns %s when customer is %s, checkout projection is %s and the checkout is enabled: %s",
+    async (expectedResult, customerId, checkout, isEnabled) => {
+      firstAvailableCheckoutByCustomerIdViewMock.mockReturnValue(checkout);
+      isCheckoutEnabledByCustomerIdViewMock.mockReturnValue(isEnabled);
+      const query = viewIsCheckoutAccessibleByCustomerId({ customerId });
+
+      const result = await queryBus(query);
+
+      expect(result).toBe(expectedResult);
+    },
+  );
+});

package/src/projection/checkout/viewIsCheckoutAccessibleByCustomerId.ts

@@ -0,0 +1,46 @@
+import { query, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+import { viewFirstAvailableCheckoutByCustomerId } from "./viewFirstAvailableCheckoutByCustomerId";
+import { viewIsCheckoutEnabledByCustomerId } from "./viewIsCheckoutEnabledByCustomerId";
+
+type IsCheckoutAccessibleByCustomerIdProjection = boolean;
+
+const VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID = "view_is_checkout_accessible_by_customer_id";
+
+interface ViewIsCheckoutAccessibleByCustomerIdPayload {
+  readonly customerId: string | undefined;
+}
+
+interface ViewIsCheckoutAccessibleByCustomerId
+  extends Query<typeof VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID>,
+    ViewIsCheckoutAccessibleByCustomerIdPayload {}
+
+interface ViewIsCheckoutAccessibleByCustomerIdFunction {
+  (payload: ViewIsCheckoutAccessibleByCustomerIdPayload): ViewIsCheckoutAccessibleByCustomerId;
+}
+
+const viewIsCheckoutAccessibleByCustomerId: ViewIsCheckoutAccessibleByCustomerIdFunction = (payload) => ({
+  ...query({ name: VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID }),
+  ...payload,
+});
+
+interface ViewIsCheckoutAccessibleByCustomerIdHandlerFunctionArgs extends QueryHandlerFunctionArgs {}
+
+const isNonEmptyCustomerId = (customerId: string | undefined): customerId is string => Boolean(customerId);
+
+const viewIsCheckoutAccessibleByCustomerIdHandler: QueryHandlerFunction<
+  ViewIsCheckoutAccessibleByCustomerId,
+  IsCheckoutAccessibleByCustomerIdProjection,
+  ViewIsCheckoutAccessibleByCustomerIdHandlerFunctionArgs
+> =
+  ({ queryBus }) =>
+  async ({ customerId }) =>
+    isNonEmptyCustomerId(customerId) &&
+    Boolean(await queryBus(viewFirstAvailableCheckoutByCustomerId({ customerId }))) &&
+    Boolean(await queryBus(viewIsCheckoutEnabledByCustomerId({ customerId })));
+
+export {
+  IsCheckoutAccessibleByCustomerIdProjection,
+  VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID,
+  viewIsCheckoutAccessibleByCustomerId,
+  viewIsCheckoutAccessibleByCustomerIdHandler,
+};

package/src/projection/checkout/viewIsCheckoutEnabledByCustomerId.test.ts

@@ -0,0 +1,20 @@
+import { QueryBus } from "@lookiero/messaging";
+import { mock } from "jest-mock-extended";
+import {
+  viewIsCheckoutEnabledByCustomerId,
+  viewIsCheckoutEnabledByCustomerIdHandler as sut,
+} from "./viewIsCheckoutEnabledByCustomerId";
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const queryBus = mock<QueryBus>();
+
+describe("viewIsCheckoutEnabledByCustomerId", () => {
+  it("returns true/false if the checkout is enabled/not by customer id", async () => {
+    const query = viewIsCheckoutEnabledByCustomerId({ customerId });
+    const view = jest.fn(() => Promise.resolve(true));
+
+    const result = await sut({ view, queryBus })(query);
+
+    expect(result).toBe(true);
+  });
+});

package/src/projection/checkout/viewIsCheckoutEnabledByCustomerId.ts

@@ -0,0 +1,51 @@
+import { query, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+
+type IsCheckoutEnabledByCustomerIdProjection = boolean;
+
+const VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID = "view_is_checkout_enabled_by_customer_id";
+
+interface ViewIsCheckoutEnabledByCustomerIdPayload {
+  readonly customerId: string;
+}
+
+interface ViewIsCheckoutEnabledByCustomerId
+  extends Query<typeof VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID>,
+    ViewIsCheckoutEnabledByCustomerIdPayload {}
+
+interface ViewIsCheckoutEnabledByCustomerIdFunction {
+  (payload: ViewIsCheckoutEnabledByCustomerIdPayload): ViewIsCheckoutEnabledByCustomerId;
+}
+
+const viewIsCheckoutEnabledByCustomerId: ViewIsCheckoutEnabledByCustomerIdFunction = (payload) => ({
+  ...query({ name: VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID }),
+  ...payload,
+});
+
+interface IsCheckoutEnabledByCustomerIdViewArgs {
+  readonly customerId: string;
+}
+
+interface IsCheckoutEnabledByCustomerIdView {
+  (args: IsCheckoutEnabledByCustomerIdViewArgs): Promise<IsCheckoutEnabledByCustomerIdProjection>;
+}
+
+interface ViewIsCheckoutEnabledByCustomerIdHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+  readonly view: IsCheckoutEnabledByCustomerIdView;
+}
+
+const viewIsCheckoutEnabledByCustomerIdHandler: QueryHandlerFunction<
+  ViewIsCheckoutEnabledByCustomerId,
+  IsCheckoutEnabledByCustomerIdProjection,
+  ViewIsCheckoutEnabledByCustomerIdHandlerFunctionArgs
+> =
+  ({ view }) =>
+  async ({ customerId }) =>
+    view({ customerId });
+
+export {
+  IsCheckoutEnabledByCustomerIdProjection,
+  VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID,
+  viewIsCheckoutEnabledByCustomerId,
+  IsCheckoutEnabledByCustomerIdView,
+  viewIsCheckoutEnabledByCustomerIdHandler,
+};

package/src/projection/uiSetting/viewUiSettingByKey.test.ts

@@ -0,0 +1,22 @@
+import { QueryBus } from "@lookiero/messaging";
+import { mock } from "jest-mock-extended";
+import { viewUiSettingByKey, viewUiSettingByKeyHandler as sut, UiSettingProjection } from "./viewUiSettingByKey";
+
+const uiSettingKey = "ui_setting_key";
+const uiSettingProjection: UiSettingProjection = {
+  id: "this-should-be-a-uuid",
+  key: uiSettingKey,
+  value: "ui_setting_value",
+};
+const queryBus = mock<QueryBus>();
+
+describe("viewUiSettingByKey", () => {
+  it("returns ui setting by key", async () => {
+    const query = viewUiSettingByKey({ key: uiSettingKey });
+    const view = jest.fn(() => Promise.resolve(uiSettingProjection));
+
+    const uiSettingProjectionResult = await sut({ view, queryBus })(query);
+
+    expect(uiSettingProjectionResult).toBe(uiSettingProjection);
+  });
+});

package/src/projection/uiSetting/viewUiSettingByKey.ts

@@ -0,0 +1,47 @@
+import { query, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+
+export interface UiSettingProjection {
+  readonly id: string;
+  readonly key: string;
+  readonly value: unknown;
+}
+
+export 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;
+}
+
+type ViewUiSettingByKeyResult = UiSettingProjection | undefined;
+
+interface UiSettingByKeyViewArgs {
+  readonly key: string;
+}
+
+export interface UiSettingByKeyView {
+  (args: UiSettingByKeyViewArgs): Promise<ViewUiSettingByKeyResult>;
+}
+
+interface ViewUiSettingByKeyHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+  readonly view: UiSettingByKeyView;
+}
+
+export const viewUiSettingByKey: ViewUiSettingByKeyFunction = (payload) => ({
+  ...query({ name: VIEW_UI_SETTING_BY_KEY }),
+  ...payload,
+});
+
+export const viewUiSettingByKeyHandler: QueryHandlerFunction<
+  ViewUiSettingByKey,
+  ViewUiSettingByKeyResult,
+  ViewUiSettingByKeyHandlerFunctionArgs
+> =
+  ({ view }) =>
+  async ({ key }) =>
+    view({ key });

package/tsconfig.build.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "exclude": [
+    "node_modules",
+    "babel.config.js",
+    "metro.config.js",
+    "jest.config.js",
+    "dist",
+    "src/Expo.tsx",
+    "**/*.test.ts",
+    "**/*.test.tsx"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "module": "esnext",
+    "allowJs": false,
+    "noEmit": false,
+    "declaration": true,
+    "strict": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noUncheckedIndexedAccess": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "exclude": ["dist"]
+}

package/webpack.config.js

@@ -0,0 +1,17 @@
+const createExpoWebpackConfigAsync = require("@expo/webpack-config");
+
+module.exports = async function (env, argv) {
+  const config = await createExpoWebpackConfigAsync(env, argv);
+
+  config.devServer.proxy = {
+    ["/local-to-dev"]: {
+      target: "https://web2.ps.dev.aws.lookiero.es/checkout/api",
+      pathRewrite: { ["^/local-to-dev"]: "" },
+      secure: false,
+      changeOrigin: true,
+      logLevel: "debug",
+    },
+  };
+
+  return config;
+};