@mframework/layer-commerce 0.0.3

package/app/composables/helpers/contextualizedNormalizers.feature

@@ -0,0 +1,14 @@
+Feature: Contextualized normalizers
+
+  Scenario: Context is passed to normalizers
+    Given a normalizer that requires a context as a second argument
+    When toContextualizedNormalizers function is called
+    And the normalizer is called with just an input
+    Then the normalizer should also receive the context
+
+  Scenario: Context changes
+    Given a normalizer that requires a context as a second argument
+    When toContextualizedNormalizers function is called
+    And the context changes
+    And the normalizer is called with just an input
+    Then the normalizer should use the recent version of the context

package/app/composables/helpers/contextualizedNormalizers.test.ts

@@ -0,0 +1,85 @@
+import { defineFeature, loadFeature } from "jest-cucumber";
+import type { ContextualizedNormalizers } from "./contextualizedNormalizers";
+import { toContextualizedNormalizers } from "./contextualizedNormalizers";
+import type { SfMoney } from "../models";
+import { beforeEach, expect, vi } from "vitest";
+
+const feature = loadFeature("./contextualizedNormalizers.feature", { loadRelativePath: true });
+
+defineFeature(feature, (test) => {
+  type TestContext = {
+    locale: string;
+    currency: string;
+  };
+  type Normalizers = {
+    normalizeMoney(context: TestContext, input: number): SfMoney;
+  };
+  let testNormalizers: Normalizers;
+  let output: ContextualizedNormalizers<Normalizers>;
+  let context: TestContext;
+
+  beforeEach(() => {
+    context = {
+      currency: "USD",
+      locale: "en",
+    };
+  });
+
+  test("Context is passed to normalizers", ({ given, when, and, then }) => {
+    given("a normalizer that requires a context as a second argument", () => {
+      testNormalizers = {
+        normalizeMoney: vi.fn((context, input) => {
+          return {
+            amount: input,
+            currency: context.currency,
+            precisionAmount: input.toFixed(2),
+          };
+        }),
+      };
+    });
+
+    when("toContextualizedNormalizers function is called", () => {
+      output = toContextualizedNormalizers(testNormalizers, () => context);
+    });
+
+    and("the normalizer is called with just an input", () => {
+      output.normalizeMoney(100);
+    });
+
+    then("the normalizer should also receive the context", () => {
+      expect(testNormalizers.normalizeMoney).toHaveBeenCalledWith(context, 100);
+    });
+  });
+  test("Context changes", ({ given, when, and, then }) => {
+    given("a normalizer that requires a context as a second argument", () => {
+      testNormalizers = {
+        normalizeMoney: vi.fn((context, input) => {
+          return {
+            amount: input,
+            currency: context.currency,
+            precisionAmount: input.toFixed(2),
+          };
+        }),
+      };
+    });
+
+    when("toContextualizedNormalizers function is called", () => {
+      output = toContextualizedNormalizers(testNormalizers, () => context);
+    });
+
+    and("the context changes", () => {
+      context.currency = "EUR";
+    });
+
+    and("the normalizer is called with just an input", () => {
+      output.normalizeMoney(100);
+    });
+
+    then("the normalizer should use the recent version of the context", () => {
+      expect(testNormalizers.normalizeMoney).toHaveBeenCalledWith(
+        expect.objectContaining({ currency: "EUR" }),
+        expect.anything(),
+      );
+    });
+  });
+});

package/app/composables/helpers/contextualizedNormalizers.ts

@@ -0,0 +1,20 @@
+import type { NormalizersConstraint } from "../defs";
+
+export type ContextualizedNormalizers<TNormalizers extends NormalizersConstraint> = {
+  [TKey in keyof TNormalizers]: (
+    input: Parameters<TNormalizers[TKey]>[1],
+  ) => ReturnType<TNormalizers[TKey]>;
+};
+
+export function toContextualizedNormalizers<
+  TNormalizers extends NormalizersConstraint,
+  TNormalizerContext extends Record<string, any>,
+>(
+  normalizers: TNormalizers,
+  getContext: () => TNormalizerContext,
+): ContextualizedNormalizers<TNormalizers> {
+  return Object.keys(normalizers).reduce((acc: any, key) => {
+    acc[key] = (input: any) => normalizers[key]!(getContext(), input);
+    return { ...acc };
+  }, {});
+}

package/app/composables/helpers/index.ts

@@ -0,0 +1 @@
+export * from "./contextualizedNormalizers";

package/app/composables/index.ts

@@ -0,0 +1,9 @@
+export * from "./defs";
+export * from "./helpers";
+export * from "./methods";
+export * from "./models";
+export * from "./validationRules";
+export * from "./registry";
+export { useCatalogFallback } from "./useCatalog";
+export { usePageTitle } from "./usePageTitle";
+

package/app/composables/methods/auth.ts

@@ -0,0 +1,83 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { Maybe, SfCustomer } from "../models";
+
+export interface RegisterCustomerExtendedArgs {}
+export interface RegisterCustomerCustomArgs {}
+
+export type RegisterCustomerArgs = {
+  email: string;
+  firstName: string;
+  lastName: string;
+  password: string;
+  //$extended?: RegisterCustomerExtendedArgs;
+  //$custom?: RegisterCustomerCustomArgs;
+};
+
+export type RegisterCustomer = (args: Simplify<RegisterCustomerArgs>) => Promise<{
+  customer: SfCustomer;
+}>;
+
+export interface LoginCustomerExtendedArgs {}
+export interface LoginCustomerCustomArgs {}
+
+export type LoginCustomerArgs = {
+  email: string;
+  password: string;
+  //$extended?: LoginCustomerExtendedArgs;
+  //$custom?: LoginCustomerCustomArgs;
+};
+
+export type LoginCustomer = (args: Simplify<LoginCustomerArgs>) => Promise<{
+  customer: SfCustomer;
+}>;
+
+export interface GetCustomerExtendedArgs {}
+export interface GetCustomerCustomArgs {}
+
+export type GetCustomerArgs = {
+  //$extended?: GetCustomerExtendedArgs;
+  //$custom?: GetCustomerCustomArgs;
+};
+
+export type GetCustomer = (args?: Simplify<GetCustomerArgs>) => Promise<{
+  customer: Maybe<SfCustomer>;
+}>;
+
+export interface LogoutCustomerExtendedArgs {}
+export interface LogoutCustomerCustomArgs {}
+
+export type LogoutCustomerArgs = {
+  //$extended?: LogoutCustomerExtendedArgs;
+  //$custom?: LogoutCustomerCustomArgs;
+};
+
+export type LogoutCustomer = (args?: Simplify<LogoutCustomerArgs>) => Promise<void>;
+
+export interface UpdateCustomerExtendedArgs {}
+export interface UpdateCustomerCustomArgs {}
+
+export type UpdateCustomerArgs = {
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  //$extended?: UpdateCustomerExtendedArgs;
+  //$custom?: UpdateCustomerCustomArgs;
+};
+
+export type UpdateCustomer = (args: Simplify<UpdateCustomerArgs>) => Promise<{
+  customer: SfCustomer;
+}>;
+
+export interface ChangeCustomerPasswordExtendedArgs {}
+export interface ChangeCustomerPasswordCustomArgs {}
+
+export type ChangeCustomerPasswordArgs = {
+  currentPassword: string;
+  // eslint-disable-next-line unicorn/no-keyword-prefix
+  newPassword: string;
+  confirmPassword: string;
+  //$extended?: ChangeCustomerPasswordExtendedArgs;
+  //$custom?: ChangeCustomerPasswordCustomArgs;
+};
+
+export type ChangeCustomerPassword = (args: Simplify<ChangeCustomerPasswordArgs>) => Promise<void>;

package/app/composables/methods/cart.ts

@@ -0,0 +1,119 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { Maybe, SfCart } from "../models";
+
+export interface GetCartExtendedArgs {}
+export interface GetCartCustomArgs {}
+
+export type GetCartArgs = {
+  /**
+   * Unique identifier of cart
+   */
+  cartId?: string;
+  //$extended?: GetCartExtendedArgs;
+  //$custom?: GetCartCustomArgs;
+};
+
+export interface AddCartLineItemExtendedArgs {}
+export interface AddCartLineItemCustomArgs {}
+
+export type AddCartLineItemArgs = {
+  /**
+   * Product unique identifier - for commercetools it's a SKU, for sap it's a product code
+   */
+  productId: string;
+  sku: Maybe<string>;
+  /**
+   * Quantity of product to add to cart
+   * @default 1
+   */
+  quantity?: number;
+  /**
+   * Unique identifier of cart
+   */
+  cartId?: string;
+  //$extended?: AddCartLineItemExtendedArgs;
+  //$custom?: AddCartLineItemCustomArgs;
+};
+
+export interface UpdateCartLineItemExtendedArgs {}
+export interface UpdateCartLineItemCustomArgs {}
+
+export type UpdateCartLineItemArgs = {
+  lineItemId: string;
+  quantity: number;
+  /**
+   * Unique identifier of cart
+   */
+  cartId?: string;
+  //$extended?: UpdateCartLineItemExtendedArgs;
+  //$custom?: UpdateCartLineItemCustomArgs;
+};
+
+export interface RemoveCartLineItemExtendedArgs {}
+export interface RemoveCartLineItemCustomArgs {}
+
+export type RemoveCartLineItemArgs = {
+  lineItemId: string;
+  /**
+   * Unique identifier of cart
+   */
+  cartId?: string;
+  //$extended?: RemoveCartLineItemExtendedArgs;
+  //$custom?: RemoveCartLineItemCustomArgs;
+};
+
+export interface ApplyCouponToCartExtendedArgs {}
+export interface ApplyCouponToCartCustomArgs {}
+
+export type ApplyCouponToCartArgs = {
+  couponCode: string;
+  /**
+   * Unique identifier of cart
+   */
+  cartId?: string;
+  //$extended?: ApplyCouponToCartExtendedArgs;
+  //$custom?: ApplyCouponToCartCustomArgs;
+};
+
+export interface RemoveCouponFromCartExtendedArgs {}
+export interface RemoveCouponFromCartCustomArgs {}
+
+export type RemoveCouponFromCartArgs = {
+  /**
+   * Don't confuse it with coupon code. It can be retrieved from cart.appliedCoupons
+   */
+  couponId: string;
+  /**
+   * Unique identifier of cart
+   */
+  cartId?: string;
+  //$extended?: RemoveCouponFromCartExtendedArgs;
+  //$custom?: RemoveCouponFromCartCustomArgs;
+};
+
+/**
+ * Get all information about customer's cart
+ */
+export type GetCart = (args?: Simplify<GetCartArgs>) => Promise<SfCart>;
+
+/**
+ * Add product to cart
+ */
+export type AddCartLineItem = (args: Simplify<AddCartLineItemArgs>) => Promise<SfCart>;
+
+/**
+ * Update product quantity in cart
+ */
+export type UpdateCartLineItem = (args: Simplify<UpdateCartLineItemArgs>) => Promise<SfCart>;
+
+/**
+ * Remove product from cart
+ */
+export type RemoveCartLineItem = (args: Simplify<RemoveCartLineItemArgs>) => Promise<SfCart>;
+
+/**
+ * Apply a coupon to cart to get a discount
+ */
+export type ApplyCouponToCart = (args: Simplify<ApplyCouponToCartArgs>) => Promise<SfCart>;
+
+export type RemoveCouponFromCart = (args: Simplify<RemoveCouponFromCartArgs>) => Promise<SfCart>;

package/app/composables/methods/category.ts

@@ -0,0 +1,27 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { SfCategory } from "../models";
+
+export interface GetCategoriesExtendedArgs {}
+export interface GetCategoriesCustomArgs {}
+
+export type GetCategoriesArgs = {
+  ids?: string[];
+  slugs?: string[];
+  //$extended?: GetCategoriesExtendedArgs;
+  //$custom?: GetCategoriesCustomArgs;
+};
+
+export type GetCategories = (args?: Simplify<GetCategoriesArgs>) => Promise<SfCategory[]>;
+
+export interface GetCategoryExtendedArgs {}
+export interface GetCategoryCustomArgs {}
+export type GetCategoryArgs = {
+  id: string;
+  //$extended?: GetCategoryExtendedArgs;
+  //$custom?: GetCategoryCustomArgs;
+};
+
+export type GetCategory = (args: Simplify<GetCategoryArgs>) => Promise<{
+  ancestors: SfCategory[];
+  category: SfCategory;
+}>;

package/app/composables/methods/checkout.ts

@@ -0,0 +1,54 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { SfCart, SfCreateAddressBody, SfCustomerAddress, SfShippingMethods } from "../models";
+
+export interface SetCustomerEmailExtendedArgs {}
+export interface SetCustomerEmailCustomArgs {}
+
+export type SetCustomerEmailArgs = {
+  email: string;
+  //$extended?: SetCustomerEmailExtendedArgs;
+  //$custom?: SetCustomerEmailCustomArgs;
+};
+
+export type SetShippingAddress = {
+  shippingAddress: SfCreateAddressBody | SfCustomerAddress;
+};
+
+export interface SetCartAddressExtendedArgs {}
+export interface SetCartAddressCustomArgs {}
+
+export type SetCartAddressArgs = SetShippingAddress & {
+  //$extended?: SetCartAddressExtendedArgs;
+  //$custom?: SetCartAddressCustomArgs;
+};
+
+export interface SetShippingMethodExtendedArgs {}
+export interface SetShippingMethodCustomArgs {}
+
+export type SetShippingMethodArgs = {
+  shippingMethodId: string;
+  //$extended?: SetShippingMethodExtendedArgs;
+  //$custom?: SetShippingMethodCustomArgs;
+};
+
+/**
+ * Set an email of active customer
+ */
+export type SetCustomerEmail = (args: Simplify<SetCustomerEmailArgs>) => Promise<SfCart>;
+
+/**
+ * Set customers adddress
+ * @example Set shipping address first
+ * setCartAddress({ shippingAddress: { ... } })
+ */
+export type SetCartAddress = (args: Simplify<SetCartAddressArgs>) => Promise<SfCart>;
+
+/**
+ * Get available shipping methods based on customer's shipping address
+ */
+export type GetAvailableShippingMethods = () => Promise<SfShippingMethods>;
+
+/**
+ * Choose a one shipping method from available shipping methods
+ */
+export type SetShippingMethod = (args: Simplify<SetShippingMethodArgs>) => Promise<SfCart>;

package/app/composables/methods/customer.ts

@@ -0,0 +1,52 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { SfCreateAddressBody, SfCustomerAddress, SfId } from "../models";
+
+export interface CreateCustomerAddressExtendedArgs {}
+export interface CreateCustomerAddressCustomArgs {}
+
+export type CreateCustomerAddressArgs = {
+  address: SfCreateAddressBody;
+  //$extended?: CreateCustomerAddressExtendedArgs;
+  //$custom?: CreateCustomerAddressCustomArgs;
+};
+
+export type CreateCustomerAddress = (args: Simplify<CreateCustomerAddressArgs>) => Promise<{
+  address: SfCustomerAddress;
+}>;
+
+export interface UpdateCustomerAddressExtendedArgs {}
+export interface UpdateCustomerAddressCustomArgs {}
+
+export type UpdateCustomerAddressArgs = {
+  id: SfId;
+  address: SfCreateAddressBody;
+  //$extended?: UpdateCustomerAddressExtendedArgs;
+  //$custom?: UpdateCustomerAddressCustomArgs;
+};
+
+export type UpdateCustomerAddress = (args: Simplify<UpdateCustomerAddressArgs>) => Promise<{
+  address: SfCustomerAddress;
+}>;
+
+export interface DeleteCustomerAddressExtendedArgs {}
+export interface DeleteCustomerAddressCustomArgs {}
+
+export type DeleteCustomerAddressArgs = {
+  id: SfId;
+  //$extended?: DeleteCustomerAddressExtendedArgs;
+  //$custom?: DeleteCustomerAddressCustomArgs;
+};
+
+export type DeleteCustomerAddress = (args: Simplify<DeleteCustomerAddressArgs>) => Promise<void>;
+
+export interface GetCustomerAddressesExtendedArgs {}
+export interface GetCustomerAddressesCustomArgs {}
+
+export type GetCustomerAddressesArgs = {
+  //$extended?: GetCustomerAddressesExtendedArgs;
+  //$custom?: GetCustomerAddressesCustomArgs;
+};
+
+export type GetCustomerAddresses = (args?: Simplify<GetCustomerAddressesArgs>) => Promise<{
+  addresses: SfCustomerAddress[];
+}>;

package/app/composables/methods/helpers.ts

@@ -0,0 +1,5 @@
+import type { SetCartAddressArgs, SetShippingAddress } from "./checkout";
+
+export function isShippingAddress(args: SetCartAddressArgs): args is SetShippingAddress {
+  return (args as SetShippingAddress).shippingAddress !== undefined;
+}

package/app/composables/methods/index.ts

@@ -0,0 +1,75 @@
+import type {
+  GetCustomer,
+  LoginCustomer,
+  LogoutCustomer,
+  RegisterCustomer,
+  UpdateCustomer,
+  ChangeCustomerPassword,
+} from "./auth";
+import type {
+  GetCart,
+  AddCartLineItem,
+  UpdateCartLineItem,
+  RemoveCartLineItem,
+  ApplyCouponToCart,
+  RemoveCouponFromCart,
+} from "./cart";
+import type { GetCategories, GetCategory } from "./category";
+import type {
+  GetAvailableShippingMethods,
+  SetCartAddress,
+  SetCustomerEmail,
+  SetShippingMethod,
+} from "./checkout";
+import type {
+  CreateCustomerAddress,
+  DeleteCustomerAddress,
+  UpdateCustomerAddress,
+  GetCustomerAddresses,
+} from "./customer";
+import type { GetOrders, GetOrderDetails, PlaceOrder } from "./order";
+import type { GetProducts, GetProductDetails, GetProductReviews, SearchProducts } from "./product";
+import type { GetCurrencies } from "./settings";
+
+export * from "./auth";
+export * from "./cart";
+export * from "./category";
+export * from "./checkout";
+export * from "./customer";
+export * from "./helpers";
+export * from "./product";
+export * from "./settings";
+export * from "./order";
+
+export type UnifiedMethods = {
+  getCart: GetCart;
+  addCartLineItem: AddCartLineItem;
+  updateCartLineItem: UpdateCartLineItem;
+  removeCartLineItem: RemoveCartLineItem;
+  applyCouponToCart: ApplyCouponToCart;
+  removeCouponFromCart: RemoveCouponFromCart;
+  getCategories: GetCategories;
+  getCategory: GetCategory;
+  getCustomer: GetCustomer;
+  loginCustomer: LoginCustomer;
+  logoutCustomer: LogoutCustomer;
+  registerCustomer: RegisterCustomer;
+  updateCustomer: UpdateCustomer;
+  changeCustomerPassword: ChangeCustomerPassword;
+  getProducts: GetProducts;
+  getProductDetails: GetProductDetails;
+  getProductReviews: GetProductReviews;
+  searchProducts: SearchProducts;
+  getAvailableShippingMethods: GetAvailableShippingMethods;
+  setCartAddress: SetCartAddress;
+  setCustomerEmail: SetCustomerEmail;
+  setShippingMethod: SetShippingMethod;
+  createCustomerAddress: CreateCustomerAddress;
+  deleteCustomerAddress: DeleteCustomerAddress;
+  updateCustomerAddress: UpdateCustomerAddress;
+  getCustomerAddresses: GetCustomerAddresses;
+  getCurrencies: GetCurrencies;
+  getOrders: GetOrders;
+  getOrderDetails: GetOrderDetails;
+  placeOrder: PlaceOrder;
+};

package/app/composables/methods/order.ts

@@ -0,0 +1,39 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { SfPagination } from "../models";
+import type { SfOrder, SfOrderListItem } from "../models/order";
+
+export interface GetOrdersExtendedArgs {}
+export interface GetOrdersCustomArgs {}
+
+export type GetOrdersArgs = {
+  pageSize?: number;
+  currentPage?: number;
+  //$extended?: GetOrdersExtendedArgs;
+  //$custom?: GetOrdersCustomArgs;
+};
+
+export type GetOrders = (args?: Simplify<GetOrdersArgs>) => Promise<{
+  orders: SfOrderListItem[];
+  pagination: SfPagination;
+}>;
+
+export interface GetOrderExtendedArgs {}
+export interface GetOrderCustomArgs {}
+
+export type GetOrderArgs = {
+  id: string;
+  //$extended?: GetOrderExtendedArgs;
+  //$custom?: GetOrderCustomArgs;
+};
+
+export type GetOrderDetails = (args: Simplify<GetOrderArgs>) => Promise<SfOrder>;
+
+export interface PlaceOrderExtendedArgs {}
+export interface PlaceOrderCustomArgs {}
+
+export type PlaceOrderArgs = {
+  //$extended?: PlaceOrderExtendedArgs;
+  //$custom?: PlaceOrderCustomArgs;
+};
+
+export type PlaceOrder = (args?: Simplify<PlaceOrderArgs>) => Promise<SfOrder>;

package/app/composables/methods/product.ts

@@ -0,0 +1,95 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type {
+  SfCategory,
+  SfFacet,
+  SfId,
+  SfPagination,
+  SfProduct,
+  SfProductCatalogItem,
+  SfProductReview,
+} from "../models";
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SfSortBy {}
+
+export interface SearchProductsExtendedArgs {}
+export interface SearchProductsCustomArgs {}
+
+export type SearchProductsArgs = {
+  pageSize?: number;
+  currentPage?: number;
+  sortBy?: "relevant" | "price-low-to-high" | "price-high-to-low" | (string & {});
+  search?: string;
+  category?: SfCategory["id"];
+  facets?: {
+    [name: string]: string[];
+  };
+  //$extended?: SearchProductsExtendedArgs;
+  //$custom?: SearchProductsCustomArgs;
+} & SfSortBy;
+
+export type SearchProducts = (args: Simplify<SearchProductsArgs>) => Promise<{
+  products: SfProductCatalogItem[];
+  pagination: SfPagination;
+  facets: SfFacet[];
+}>;
+
+export interface GetProductsExtendedArgs {}
+export interface GetProductsCustomArgs {}
+
+export type GetProductsArgs = {
+  ids?: string[];
+  skus?: string[];
+  //$extended?: GetProductsExtendedArgs;
+  //$custom?: GetProductsCustomArgs;
+};
+
+export type GetProducts = (args: Simplify<GetProductsArgs>) => Promise<{
+  products: SfProductCatalogItem[];
+}>;
+
+export interface GetProductDetailsExtendedArgs {}
+export interface GetProductDetailsCustomArgs {}
+
+export type GetProductDetailsArgs = {
+  id: SfId;
+  sku?: string;
+  //$extended?: GetProductDetailsExtendedArgs;
+  //$custom?: GetProductDetailsCustomArgs;
+};
+
+export type GetProductDetails = (args: Simplify<GetProductDetailsArgs>) => Promise<{
+  product: SfProduct;
+  categoryHierarchy: SfCategory[];
+}>;
+
+export interface GetProductReviewsExtendedArgs {}
+export interface GetProductReviewsCustomArgs {}
+
+export type GetProductReviewsArgs = {
+  productId: SfId;
+  pageSize?: number;
+  currentPage?: number;
+  //$extended?: GetProductReviewsExtendedArgs;
+  //$custom?: GetProductReviewsCustomArgs;
+};
+
+export type GetProductReviews = (args: Simplify<GetProductReviewsArgs>) => Promise<{
+  reviews: SfProductReview[];
+  pagination: SfPagination;
+}>;
+
+export interface AddProductReviewExtendedArgs {}
+export interface AddProductReviewCustomArgs {}
+
+export type AddProductReviewArgs = {
+  productId: SfId;
+  productSku?: string;
+  review: Pick<SfProductReview, "title" | "text" | "rating" | "reviewer">;
+  //$extended?: AddProductReviewExtendedArgs;
+  //$custom?: AddProductReviewCustomArgs;
+};
+
+export type AddProductReview = (args: Simplify<AddProductReviewArgs>) => Promise<{
+  review: SfProductReview;
+}>;