Merge b60b3a2 into ea2c90a

packages/core/core/src/factories/index.ts

@@ -10,3 +10,5 @@ export * from './apiClientFactory';
 export * from './useReviewFactory';
 export * from './useFacetFactory';
 export * from './useContentFactory';
+export * from './useCheckoutShippingFactory';
+export * from './useCheckoutShippingMethodFactory';

packages/core/core/src/factories/useCheckoutShippingFactory.ts

@@ -0,0 +1,64 @@
+import { UseCheckoutShipping, Context, FactoryParams, UseCheckoutShippingErrors } from '../types';
+import { Ref, computed } from '@vue/composition-api';
+import { sharedRef, Logger, generateContext } from '../utils';
+
+export interface UseCheckoutShippingParams<SHIPPING, SHIPPING_PARAMS> extends FactoryParams {
+  load: (context: Context) => Promise<SHIPPING>;
+  save: (context: Context, params: SHIPPING_PARAMS) => Promise<SHIPPING>;
+}
+
+export const useCheckoutShippingFactory = <SHIPPING, SHIPPING_PARAMS>(
+  factoryParams: UseCheckoutShippingParams<SHIPPING, SHIPPING_PARAMS>
+) => {
+  return function useCheckoutShipping (): UseCheckoutShipping<SHIPPING, SHIPPING_PARAMS> {
+    const loading: Ref<boolean> = sharedRef(false, 'useCheckoutShipping-loading');
+    const shipping: Ref<SHIPPING> = sharedRef(null, 'useCheckoutShipping-shipping');
+    const context = generateContext(factoryParams);
+    const error: Ref<UseCheckoutShippingErrors> = sharedRef({}, 'useCheckoutShipping-error');
+
+    const load = async () => {
+      Logger.debug('useCheckoutShipping.load');
+
+      try {
+        loading.value = true;
+        error.value.load = null;
+        const shippingInfo = await factoryParams.load(
+          context
+        );
+        shipping.value = shippingInfo;
+      } catch (err) {
+        error.value.load = err;
+        Logger.error('useCheckoutShipping/load', err);
+      } finally {
+        loading.value = false;
+      }
+    };
+
+    const save = async (params: SHIPPING_PARAMS) => {
+      Logger.debug('useCheckoutShipping.save');
+
+      try {
+        loading.value = true;
+        error.value.save = null;
+        const shippingInfo = await factoryParams.save(
+          context,
+          params
+        );
+        shipping.value = shippingInfo;
+      } catch (err) {
+        error.value.save = err;
+        Logger.error('useCheckoutShipping/save', err);
+      } finally {
+        loading.value = false;
+      }
+    };
+
+    return {
+      shipping: computed(() => shipping.value),
+      loading: computed(() => loading.value),
+      error: computed(() => error.value),
+      load,
+      save
+    };
+  };
+};

packages/core/core/src/factories/useCheckoutShippingMethodFactory.ts

@@ -0,0 +1,64 @@
+import { UseCheckoutShippingMethod, Context, FactoryParams, UseCheckoutShippingMethodErrors } from '../types';
+import { Ref, computed } from '@vue/composition-api';
+import { sharedRef, Logger, generateContext } from '../utils';
+
+export interface UseCheckoutShippingMethodParams<SHIPPING_METHODS, SHIPPING_METHOD_PARAMS> extends FactoryParams {
+  load: (context: Context) => Promise<SHIPPING_METHODS>;
+  save: (context: Context, params: SHIPPING_METHOD_PARAMS) => Promise<SHIPPING_METHODS>;
+}
+
+export const useCheckoutShippingMethodFactory = <SHIPPING_METHODS, SHIPPING_METHOD_PARAMS>(
+  factoryParams: UseCheckoutShippingMethodParams<SHIPPING_METHODS, SHIPPING_METHOD_PARAMS>
+) => {
+  return function useCheckoutShippingMethod (): UseCheckoutShippingMethod<SHIPPING_METHODS, SHIPPING_METHOD_PARAMS> {
+    const loading: Ref<boolean> = sharedRef(false, 'useCheckoutShippingMethod-loading');
+    const shippingMethods: Ref<SHIPPING_METHODS> = sharedRef(null, 'useCheckoutShippingMethod-shipping');
+    const context = generateContext(factoryParams);
+    const error: Ref<UseCheckoutShippingMethodErrors> = sharedRef({}, 'useCheckoutShippingMethod-error');
+
+    const load = async () => {
+      Logger.debug('useCheckoutShippingMethod.load');
+
+      try {
+        loading.value = true;
+        error.value.load = null;
+        const shippingInfo = await factoryParams.load(
+          context
+        );
+        shippingMethods.value = shippingInfo;
+      } catch (err) {
+        error.value.load = err;
+        Logger.error('useCheckoutShippingMethod/load', err);
+      } finally {
+        loading.value = false;
+      }
+    };
+
+    const save = async (params: SHIPPING_METHOD_PARAMS) => {
+      Logger.debug('useCheckoutShippingMethod.save');
+
+      try {
+        loading.value = true;
+        error.value.save = null;
+        const shippingInfo = await factoryParams.save(
+          context,
+          params
+        );
+        shippingMethods.value = shippingInfo;
+      } catch (err) {
+        error.value.save = err;
+        Logger.error('useCheckoutShippingMethod/save', err);
+      } finally {
+        loading.value = false;
+      }
+    };
+
+    return {
+      shippingMethods: computed(() => shippingMethods.value),
+      loading: computed(() => loading.value),
+      error: computed(() => error.value),
+      load,
+      save
+    };
+  };
+};

packages/core/core/src/types.ts

@@ -277,6 +277,54 @@ export interface UseReview<REVIEW, REVIEWS_SEARCH_PARAMS, REVIEW_ADD_PARAMS> {
   loading: ComputedProperty<boolean>;
   [x: string]: any;
 }
+export interface UseCheckoutShipping<SHIPPING, SHIPPING_PARAMS> {
+  shipping: ComputedProperty<SHIPPING>;
+  error: ComputedProperty<UseCheckoutShippingErrors>;
+  loading: ComputedProperty<boolean>;
+  load: () => Promise<void>;
+  save: (params: SHIPPING_PARAMS) => Promise<void>;
+}
+export interface UseCheckoutShippingErrors {
+  load?: Error;
+  save?: Error;
+}
+export interface UseCheckoutShippingMethodErrors {
+  load?: Error;
+  save?: Error;
+}
+export interface UseCheckoutShippingMethod<SHIPPING_METHODS, SHIPPING_METHOD_PARAMS> {
+  shippingMethods: ComputedProperty<SHIPPING_METHODS>;
+  error: ComputedProperty<UseCheckoutShippingErrors>;
+  loading: ComputedProperty<boolean>;
+  load: () => Promise<void>;
+  save: (params: SHIPPING_METHOD_PARAMS) => Promise<void>;
+}
+export interface UseCheckoutShippingGetters<SHIPPING, SHIPPING_ADDRESS_ITEM, SHIPPING_METHOD_ITEM> {
+  getAddresses: (billing: SHIPPING, criteria?: Record<string, any>) => SHIPPING_ADDRESS_ITEM[];
+  getMethods: (billing: SHIPPING, criteria?: Record<string, any>) => SHIPPING_METHOD_ITEM[];
+  getAddressPostCode: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressStreetName: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressStreetNumber: (address: SHIPPING_ADDRESS_ITEM) => string | number;
+  getAddressCity: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressFirstName: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressLastName: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressCountry: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressPhone: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressEmail: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressProvince: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressCompanyName: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressTaxNumber: (address: SHIPPING_ADDRESS_ITEM) => string;
+  getAddressApartmentNumber: (address: SHIPPING_ADDRESS_ITEM) => string | number;
+  isAddressDefault: (address: SHIPPING_ADDRESS_ITEM) => boolean;
+}
+
+export interface UseCheckoutShippingMethodGetters<SHIPPING_METHODS, SHIPPING_MEDHOD_ITEM> {
+  getShippingMethods: (methods: SHIPPING_METHODS, criteria?: Record<string, any>) => SHIPPING_MEDHOD_ITEM[];
+  getMethodName: (method: SHIPPING_MEDHOD_ITEM) => string;
+  getMethodDescription: (method: SHIPPING_MEDHOD_ITEM) => string;
+  getMethodPrice: (method: SHIPPING_MEDHOD_ITEM) => AgnosticPrice;
+  isMethodDefault: (method: SHIPPING_MEDHOD_ITEM) => boolean;
+}
 export interface UseFacetErrors {
   search?: Error;
 }