@mframework/layer-commerce 0.0.3

package/app/composables/methods/settings.ts

@@ -0,0 +1,16 @@
+import type { Simplify } from '../defs/typeHelpers';
+import type { SfCurrency } from "../models";
+
+export interface GetCurrenciesExtendedArgs {}
+export interface GetCurrenciesCustomArgs {}
+
+export type GetCurrenciesArgs = {
+  //$extended?: GetCurrenciesExtendedArgs;
+  //$custom?: GetCurrenciesCustomArgs;
+};
+
+export type GetCurrencies = (args?: Simplify<GetCurrenciesArgs>) => Promise<{
+  currencies: SfCurrency[];
+  defaultCurrency: SfCurrency;
+  currentCurrency: SfCurrency;
+}>;

package/app/composables/models/cart.ts

@@ -0,0 +1,95 @@
+import type { InferCustom } from "../defs";
+import type { SfShippingMethod } from "./checkout";
+import type {
+  Maybe,
+  SfAddress,
+  SfAttribute,
+  SfDiscountablePrice,
+  SfId,
+  SfImage,
+  SfMoney,
+} from "./shared";
+
+export interface SfCartLineItemCustom extends InferCustom<"normalizeCartLineItem"> {}
+
+export interface SfCartLineItem {
+  attributes: SfAttribute[];
+  productId: SfId;
+  /**
+   * ID of the cart's line item
+   */
+  id: SfId;
+  image: Maybe<SfImage>;
+  name: Maybe<string>;
+  quantity: number;
+  sku: Maybe<string>;
+  slug: string;
+  /**
+   * Product of quantity and unitPrice
+   */
+  totalPrice: Maybe<SfMoney>;
+  unitPrice: Maybe<SfDiscountablePrice>;
+  quantityLimit: Maybe<number>;
+  $custom?: SfCartLineItemCustom;
+}
+
+export interface SfCartCouponCustom extends InferCustom<"normalizeCartCoupon"> {}
+
+export interface SfCartCoupon {
+  code: string;
+  id: string;
+  name: Maybe<string>;
+  $custom?: SfCartCouponCustom;
+}
+
+export interface SfCartCustom extends InferCustom<"normalizeCart"> {}
+
+export interface SfCart {
+  appliedCoupons: SfCartCoupon[];
+  /**
+   * @default null
+   */
+  billingAddress: Maybe<SfAddress>;
+  /**
+   * Active customer's email. Required to complete the checkout
+   * @default null
+   */
+  customerEmail: Maybe<string>;
+  id: SfId;
+  /**
+   * Shipping address is required to get available shipping methods
+   * @default null
+   */
+  lineItems: SfCartLineItem[];
+  shippingAddress: Maybe<SfAddress>;
+  /**
+   * Required to complete the checkout. To get available methods use `getAvailableShippingMethods`
+   * @default null
+   */
+  shippingMethod: Maybe<SfShippingMethod>;
+  /**
+   * Difference of `subtotalRegularPrice` and discounts applied to line items before providing coupons.
+   * If none of the products are discounted, price will be equal to `subtotalRegularPrice`
+   */
+  subtotalDiscountedPrice: SfMoney;
+  /**
+   * Total regular price of all line items (coupons, taxes, shipping excluded)
+   */
+  subtotalRegularPrice: SfMoney;
+  totalCouponDiscounts: SfMoney;
+  /**
+   * Total count of all line items and their's quantities in cart
+   */
+  totalItems: number;
+  /**
+   * Total cart price (discounts, taxes, shipping included)
+   */
+  totalPrice: SfMoney;
+  /**
+   * Calculated after applying shipping method
+   * @default null
+   */
+  totalShippingPrice: Maybe<SfMoney>;
+  totalTax: SfMoney;
+  $custom?: SfCartCustom;
+}

package/app/composables/models/category.ts

@@ -0,0 +1,13 @@
+import type { InferCustom } from "../defs";
+import type { Maybe, SfId } from "./shared";
+
+export interface SfCategoryCustom extends InferCustom<"normalizeCartCoupon"> {}
+
+export interface SfCategory {
+  id: SfId;
+  name: string;
+  slug: string;
+  subcategories: Maybe<SfCategory[]>;
+  parentCategoryId: Maybe<SfId>;
+  $custom?: SfCategoryCustom;
+}

package/app/composables/models/checkout.ts

@@ -0,0 +1,17 @@
+import type { InferCustom } from "../defs";
+import type { Maybe, SfMoney } from "./shared";
+
+export interface SfShippingMethodCustom extends InferCustom<"normalizeCartCoupon"> {}
+
+export interface SfShippingMethod {
+  description: Maybe<string>;
+  estimatedDelivery: Maybe<string>;
+  id: string;
+  name: string;
+  price: SfMoney;
+  $custom?: SfShippingMethodCustom;
+}
+
+export interface SfShippingMethods {
+  methods: SfShippingMethod[];
+}

package/app/composables/models/customer.ts

@@ -0,0 +1,16 @@
+import type { InferCustom } from "../defs";
+import type { SfAddress, SfId } from "./shared";
+
+export interface SfCustomerCustom extends InferCustom<"normalizeCustomer"> {}
+
+export interface SfCustomer {
+  id: SfId;
+  email: string;
+  firstName: string;
+  lastName: string;
+  $custom?: SfCustomerCustom;
+}
+
+export interface SfCustomerAddress extends SfAddress {
+  id: SfId;
+}

package/app/composables/models/facets.ts

@@ -0,0 +1,25 @@
+import type { InferCustom } from "../defs";
+import type { Maybe } from "./shared";
+
+export enum SfFacetTypes {
+  MULTI_SELECT = "MULTI_SELECT",
+  SINGLE_SELECT = "SINGLE_SELECT",
+}
+
+export type SfFacetType = `${SfFacetTypes}`;
+
+export interface SfFacetItem {
+  label: string;
+  value: string;
+  productCount: Maybe<number>;
+}
+
+export interface SfFacetCustom extends InferCustom<"normalizeFacet"> {}
+
+export interface SfFacet {
+  label: string;
+  name: string;
+  values: SfFacetItem[];
+  type: Maybe<SfFacetType | (string & Record<never, never>)>;
+  $custom?: SfFacetCustom;
+}

package/app/composables/models/index.ts

@@ -0,0 +1,94 @@
+import type { SfCart, SfCartCoupon, SfCartCouponCustom, SfCartLineItemCustom } from "./cart";
+import type { SfCategory, SfCategoryCustom } from "./category";
+import type { SfShippingMethod, SfShippingMethodCustom, SfShippingMethods } from "./checkout";
+import type { SfCustomer, SfCustomerAddress, SfCustomerCustom } from "./customer";
+import type { SfFacet, SfFacetCustom, SfFacetItem, SfFacetType, SfFacetTypes } from "./facets";
+import type {
+  SfOrder,
+  SfOrderCustom,
+  SfOrderLineItem,
+  SfOrderLineItemCustom,
+  SfOrderListItem,
+  SfOrderListItemCustom,
+} from "./order";
+import type {
+  SfPagination,
+  SfPaginationCustom,
+  SfProduct,
+  SfProductCatalogItem,
+  SfProductCatalogItemCustom,
+  SfProductCustom,
+  SfProductReview,
+  SfProductReviewCustom,
+  SfProductVariant,
+} from "./product";
+import type {
+  SfAddress,
+  SfAddressCustom,
+  SfAttribute,
+  SfAttributeCustom,
+  SfCreateAddressBody,
+  SfCurrency,
+  SfDiscountablePrice,
+  SfDiscountablePriceCustom,
+  SfImage,
+  SfImageCustom,
+  SfMoney,
+  SfMoneyCustom,
+} from "./shared";
+
+export * from "./cart";
+export * from "./category";
+export * from "./checkout";
+export * from "./customer";
+export * from "./facets";
+export * from "./product";
+export * from "./shared";
+export * from "./order";
+
+export interface SfContract {
+  SfCartLineItemCustom: SfCartLineItemCustom;
+  SfCartCouponCustom: SfCartCouponCustom;
+  SfCartCoupon: SfCartCoupon;
+  SfCart: SfCart;
+  SfCategoryCustom: SfCategoryCustom;
+  SfCategory: SfCategory;
+  SfShippingMethodCustom: SfShippingMethodCustom;
+  SfShippingMethod: SfShippingMethod;
+  SfShippingMethods: SfShippingMethods;
+  SfCustomerCustom: SfCustomerCustom;
+  SfCustomer: SfCustomer;
+  SfCustomerAddress: SfCustomerAddress;
+  SfFacetTypes: SfFacetTypes;
+  SfFacetType: SfFacetType;
+  SfFacetItem: SfFacetItem;
+  SfFacetCustom: SfFacetCustom;
+  SfFacet: SfFacet;
+  SfOrderLineItemCustom: SfOrderLineItemCustom;
+  SfOrderLineItem: SfOrderLineItem;
+  SfOrderCustom: SfOrderCustom;
+  SfOrder: SfOrder;
+  SfOrderListItemCustom: SfOrderListItemCustom;
+  SfOrderListItem: SfOrderListItem;
+  SfProductVariant: SfProductVariant;
+  SfProductReviewCustom: SfProductReviewCustom;
+  SfProductReview: SfProductReview;
+  SfProductCustom: SfProductCustom;
+  SfProduct: SfProduct;
+  SfProductCatalogItemCustom: SfProductCatalogItemCustom;
+  SfProductCatalogItem: SfProductCatalogItem;
+  SfPaginationCustom: SfPaginationCustom;
+  SfPagination: SfPagination;
+  SfMoneyCustom: SfMoneyCustom;
+  SfMoney: SfMoney;
+  SfDiscountablePriceCustom: SfDiscountablePriceCustom;
+  SfDiscountablePrice: SfDiscountablePrice;
+  SfImageCustom: SfImageCustom;
+  SfImage: SfImage;
+  SfAttributeCustom: SfAttributeCustom;
+  SfAttribute: SfAttribute;
+  SfCreateAddressBody: SfCreateAddressBody;
+  SfAddressCustom: SfAddressCustom;
+  SfAddress: SfAddress;
+  SfCurrency: SfCurrency;
+}

package/app/composables/models/order.ts

@@ -0,0 +1,43 @@
+import type { InferCustom } from "../defs";
+import type { SfShippingMethod } from "./checkout";
+import type { Maybe, SfAddress, SfAttribute, SfId, SfImage, SfMoney } from "./shared";
+
+export interface SfOrderLineItemCustom extends InferCustom<"normalizeOrderLineItem"> {}
+
+export interface SfOrderLineItem {
+  id: SfId;
+  attributes: SfAttribute[];
+  unitPrice: SfMoney;
+  totalPrice: SfMoney;
+  quantity: number;
+  image: Maybe<SfImage>;
+  productId: SfId;
+  productName: string;
+  sku: Maybe<string>;
+  $custom?: SfOrderLineItemCustom;
+}
+
+export interface SfOrderCustom extends InferCustom<"normalizeOrder"> {}
+
+export interface SfOrder {
+  id: SfId;
+  orderDate: string;
+  status: string;
+  lineItems: SfOrderLineItem[];
+  subtotalPrice: SfMoney;
+  totalShippingPrice: SfMoney;
+  totalTax: SfMoney;
+  totalPrice: SfMoney;
+  shippingAddress: SfAddress;
+  billingAddress: Maybe<SfAddress>;
+  shippingMethod: SfShippingMethod;
+  paymentMethod: string;
+  $custom?: SfOrderCustom;
+}
+
+export interface SfOrderListItemCustom extends InferCustom<"normalizeOrder"> {}
+
+export interface SfOrderListItem
+  extends Pick<SfOrder, "id" | "orderDate" | "totalPrice" | "status"> {
+  $custom?: SfOrderListItemCustom;
+}

package/app/composables/models/product.ts

@@ -0,0 +1,73 @@
+import type { InferCustom } from "../defs";
+import type { Maybe, SfAttribute, SfDiscountablePrice, SfId, SfImage } from "./shared";
+
+export interface SfProductVariant {
+  id: SfId;
+  slug: string;
+  sku: Maybe<string>;
+  name: Maybe<string>;
+  /*
+   * Maximum available quantity for variant, null if unlimited
+   */
+  quantityLimit: Maybe<number>;
+  attributes: SfAttribute[];
+}
+
+export interface SfProductReviewCustom extends InferCustom<"normalizeProductReview"> {}
+
+export interface SfProductReview {
+  id: SfId;
+  title: Maybe<string>;
+  text: Maybe<string>;
+  rating: Maybe<number>;
+  /*
+   * Name of the reviewer (Full name or nickname)
+   */
+  reviewer: Maybe<string>;
+  /*
+   * Creation date in ISO 8601 format
+   */
+  createdAt: string;
+  $custom?: SfProductReviewCustom;
+}
+
+export interface SfProductCustom extends InferCustom<"normalizeProduct"> {}
+
+export interface SfProduct {
+  id: SfId;
+  sku: Maybe<string>;
+  name: Maybe<string>;
+  slug: string;
+  description: Maybe<string>;
+  price: Maybe<SfDiscountablePrice>;
+  primaryImage: Maybe<SfImage>;
+  gallery: SfImage[];
+  rating: Maybe<{
+    average: number;
+    count: number;
+  }>;
+  variants: SfProductVariant[];
+  attributes: SfAttribute[];
+  /*
+   * Maximum available quantity for product, null if unlimited
+   */
+  quantityLimit: Maybe<number>;
+  $custom?: SfProductCustom;
+}
+
+export interface SfProductCatalogItemCustom extends InferCustom<"normalizeProductCatalogItem"> {}
+
+export interface SfProductCatalogItem
+  extends Omit<SfProduct, "variants" | "gallery" | "description" | "attributes"> {
+  $custom?: SfProductCatalogItemCustom;
+}
+
+export interface SfPaginationCustom extends InferCustom<"normalizePagination"> {}
+
+export interface SfPagination {
+  currentPage: number;
+  pageSize: Maybe<number>;
+  totalResults: number;
+  totalPages: number;
+  $custom?: SfPaginationCustom;
+}

package/app/composables/models/shared.ts

@@ -0,0 +1,75 @@
+import type { InferCustom } from "../defs";
+
+export type Maybe<TType> = TType | null;
+
+export type SfId = string;
+
+export interface SfMoneyCustom extends InferCustom<"normalizeMoney"> {}
+
+export interface SfMoney {
+  currency: string;
+  amount: number;
+  precisionAmount: string;
+  $custom?: SfMoneyCustom;
+}
+
+export interface SfDiscountablePriceCustom extends InferCustom<"normalizeDiscountablePrice"> {}
+
+export interface SfDiscountablePrice {
+  isDiscounted: boolean;
+  regularPrice: SfMoney;
+  /**
+   * Price with discounts. If there is no discount, it will be the same as regularPrice
+   */
+  value: SfMoney;
+  $custom?: SfDiscountablePriceCustom;
+}
+
+export interface SfImageCustom extends InferCustom<"normalizeImage"> {}
+
+export interface SfImage {
+  alt: Maybe<string>;
+  url: string;
+  $custom?: SfImageCustom;
+}
+
+export interface SfAttributeCustom extends InferCustom<"normalizeAttribute"> {}
+
+export interface SfAttribute {
+  label: string;
+  name: string;
+  value: string;
+  valueLabel: string;
+  $custom?: SfAttributeCustom;
+}
+
+export interface SfCreateAddressBody {
+  address1: string;
+  address2?: Maybe<string>;
+  city: string;
+  country: string;
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  postalCode: string;
+  state: string;
+  titleCode: string;
+}
+
+export interface SfAddressCustom extends InferCustom<"normalizeAddress"> {}
+
+export interface SfAddress {
+  address1: Maybe<string>;
+  address2?: Maybe<string>;
+  city: Maybe<string>;
+  country: Maybe<string>;
+  firstName: Maybe<string>;
+  lastName: Maybe<string>;
+  phoneNumber: Maybe<string>;
+  postalCode: Maybe<string>;
+  state: Maybe<string>;
+  titleCode: Maybe<string>;
+  $custom?: SfAddressCustom;
+}
+
+export type SfCurrency = string;

package/app/composables/orders.ts

@@ -0,0 +1,69 @@
+import { getCommerceClient } from '../utils/client'
+
+function clientOrNull() {
+  try {
+    return getCommerceClient()
+  } catch (e) {
+    return null
+  }
+}
+
+export function useOrders() {
+  const client = clientOrNull()
+  return {
+    async getOrders(filters: any = {}) {
+      if (client && typeof client.listOrders === 'function') return client.listOrders(filters)
+      return []
+    },
+    async getOrderById(id: string) {
+      if (client && typeof client.getOrder === 'function') return client.getOrder(id)
+      return null
+    }
+  }
+}
+
+export function useReturns() {
+  const client = clientOrNull()
+  return {
+    async getReturns(opts: any = {}) {
+      if (client && typeof client.listReturns === 'function') return client.listReturns(opts)
+      return []
+    },
+    async createReturn(data: any) {
+      if (client && typeof client.createReturn === 'function') return client.createReturn(data)
+      return null
+    }
+  }
+}
+
+export function useTransactions() {
+  const client = clientOrNull()
+  return {
+    async getTransactions(opts: any = {}) {
+      if (client && typeof client.listTransactions === 'function') return client.listTransactions(opts)
+      return []
+    }
+  }
+}
+
+export function useInvoices() {
+  const client = clientOrNull()
+  return {
+    async getInvoices(opts: any = {}) {
+      if (client && typeof client.listInvoices === 'function') return client.listInvoices(opts)
+      return []
+    }
+  }
+}
+
+export function useCreditMemos() {
+  const client = clientOrNull()
+  return {
+    async getCreditMemos(opts: any = {}) {
+      if (client && typeof client.listCreditMemos === 'function') return client.listCreditMemos(opts)
+      return []
+    }
+  }
+}
+
+export default useOrders

package/app/composables/products/registry.ts

@@ -0,0 +1,86 @@
+import { ProductProvider } from "./types"
+
+// Product providers
+const providers: Record<string, ProductProvider> = {}
+
+export function registerProductProvider(name: string, provider: ProductProvider) {
+  providers[name] = provider
+}
+
+export function getProductProvider(name: string) {
+  const provider = providers[name]
+  if (!provider) throw new Error(`Product provider "${name}" not found`)
+  return provider
+}
+
+export function registerProductProviderRuntime(name: string, provider: ProductProvider) {
+  registerProductProvider(name, provider)
+}
+
+// Event providers (optional domain)
+type EventProvider = {
+  getEvent?(id: string): Promise<any>
+  listEvents?(params?: Record<string, any>): Promise<any[]>
+}
+
+const eventProviders: Record<string, EventProvider> = {}
+
+export function registerEventProvider(name: string, provider: EventProvider) {
+  eventProviders[name] = provider
+}
+
+export function getEventProvider(name: string) {
+  const provider = eventProviders[name]
+  if (!provider) throw new Error(`Event provider "${name}" not found`)
+  return provider
+}
+
+export function registerEventProviderRuntime(name: string, provider: EventProvider) {
+  registerEventProvider(name, provider)
+}
+
+// Gift card providers (optional domain)
+type GiftCardProvider = {
+  getGiftCard?(id: string): Promise<any>
+  listGiftCards?(params?: Record<string, any>): Promise<any[]>
+  redeemGiftCard?(code: string): Promise<any>
+}
+
+const giftCardProviders: Record<string, GiftCardProvider> = {}
+
+export function registerGiftCardProvider(name: string, provider: GiftCardProvider) {
+  giftCardProviders[name] = provider
+}
+
+export function getGiftCardProvider(name: string) {
+  const provider = giftCardProviders[name]
+  if (!provider) throw new Error(`Gift card provider "${name}" not found`)
+  return provider
+}
+
+export function registerGiftCardProviderRuntime(name: string, provider: GiftCardProvider) {
+  registerGiftCardProvider(name, provider)
+}
+
+// Subscription providers (optional domain)
+type SubscriptionProvider = {
+  getSubscription?(id: string): Promise<any>
+  listSubscriptions?(params?: Record<string, any>): Promise<any[]>
+  subscribe?(payload: Record<string, any>): Promise<any>
+}
+
+const subscriptionProviders: Record<string, SubscriptionProvider> = {}
+
+export function registerSubscriptionProvider(name: string, provider: SubscriptionProvider) {
+  subscriptionProviders[name] = provider
+}
+
+export function getSubscriptionProvider(name: string) {
+  const provider = subscriptionProviders[name]
+  if (!provider) throw new Error(`Subscription provider "${name}" not found`)
+  return provider
+}
+
+export function registerSubscriptionProviderRuntime(name: string, provider: SubscriptionProvider) {
+  registerSubscriptionProvider(name, provider)
+}

package/app/composables/products/types.ts

@@ -0,0 +1,8 @@
+import { Product } from '../../types/domain'
+
+export type { Product }
+
+export interface ProductProvider {
+  getProduct(id: string): Promise<Product>
+  listProducts(params?: Record<string, any>): Promise<Product[]>
+}

package/app/composables/products/useEvents.ts

@@ -0,0 +1,26 @@
+
+import { getCommerceConfig } from '../config'
+import { getEventProvider } from './registry'
+
+export function useEvents() {
+	const cfg = getCommerceConfig() as any
+	const providerName = cfg.eventsProvider || cfg.productProvider
+
+	let provider: any
+	try {
+		provider = getEventProvider(providerName)
+	} catch (e) {
+		provider = {
+			getEvent: async () => null,
+			listEvents: async () => []
+		}
+	}
+
+	return {
+		getEvent: provider.getEvent ?? (async (id: string) => null),
+		listEvents: provider.listEvents ?? (async (params?: Record<string, any>) => [])
+	}
+}
+
+export default useEvents
+

package/app/composables/products/useGiftCards.ts

@@ -0,0 +1,29 @@
+
+import { getCommerceConfig } from '../config'
+import { getGiftCardProvider } from './registry'
+
+export function useGiftCards() {
+	const cfg = getCommerceConfig() as any
+	const providerName = cfg.giftCardsProvider || cfg.productProvider
+
+	let provider: any
+	try {
+		provider = getGiftCardProvider(providerName)
+	} catch (e) {
+		provider = {
+			getGiftCard: async () => null,
+			listGiftCards: async () => [],
+			redeemGiftCard: async () => ({ success: false })
+		}
+	}
+
+	return {
+		getGiftCard: provider.getGiftCard ?? (async (id: string) => null),
+		listGiftCards: provider.listGiftCards ?? (async (params?: Record<string, any>) => []),
+		redeemGiftCard: provider.redeemGiftCard ?? (async (code: string) => ({ success: false }))
+	}
+}
+
+export default useGiftCards
+
+