Merge pull request #5330 from vuestorefront/unifi-return-properties

Unify the returning properties in composables

packages/commercetools/api-client/__tests__/api/getMyOrders.spec.ts → packages/commercetools/api-client/__tests__/api/getOrders.spec.ts

@@ -1,8 +1,8 @@
-import getOrders from '../../src/api/getMyOrders';
-import defaultQuery from '../../src/api/getMyOrders/defaultQuery';
+import getOrders from '../../src/api/getOrders';
+import defaultQuery from '../../src/api/getOrders/defaultQuery';
 import { OrderWhereSearch } from '../../src/types/Api';
 
-describe('[commercetools-api-client] getMyOrders', () => {
+describe('[commercetools-api-client] getOrders', () => {
   const params: OrderWhereSearch = {
     id: 'fvdrt8gaw4r',
     limit: 10,

packages/commercetools/composables/__tests__/useCart/useCart.spec.ts

@@ -1,4 +1,4 @@
-import { useCart } from './../../src/useCart';
+import useCart from './../../src/useCart';
 import loadCurrentCart from './../../src/useCart/currentCart';
 
 const context = {
@@ -17,9 +17,7 @@ const context = {
 
 jest.mock('./../../src/useCart/currentCart');
 jest.mock('@vue-storefront/core', () => ({
-  useCartFactory: (params) => ({
-    useCart: () => params
-  })
+  useCartFactory: (params) => () => params
 }));
 
 const customQuery = undefined;
@@ -29,24 +27,6 @@ describe('[commercetools-composables] useCart', () => {
     jest.clearAllMocks();
   });
 
-  // it('loads current cart when there is user session', async () => {
-  //   (isTokenUserSession as any).mockReturnValue(true);
-  //   const { loadCart } = useCart() as any;
-
-  //   loadCart();
-
-  //   expect(loadCurrentCart).toBeCalled();
-  // });
-
-  // it('does not loads cart without user session', async () => {
-  //   (isTokenUserSession as any).mockReturnValue(false);
-  //   const { loadCart } = useCart() as any;
-
-  //   loadCart();
-
-  //   expect(loadCurrentCart).not.toBeCalled();
-  // });
-
   it('adds to cart', async () => {
     const { addItem } = useCart() as any;
     const response = await addItem(context, { currentCart: 'current cart', product: 'product1', quantity: 3 });

packages/commercetools/composables/__tests__/useProduct/useProduct.spec.ts

@@ -47,10 +47,7 @@ describe('[commercetools-composables] useProduct', () => {
 
     const response = await productsSearch(context, { id: 'product-id' });
 
-    expect(response).toEqual({
-      data: [product('prod1', 'prod-1', 'xxx1'), product('prod2', 'prod-2', 'xxx2')],
-      total: 54
-    });
+    expect(response).toEqual([product('prod1', 'prod-1', 'xxx1'), product('prod2', 'prod-2', 'xxx2')]);
     expect(context.$ct.api.getProduct).toBeCalledWith({ id: 'product-id' }, undefined);
     expect(enhanceProducts).toBeCalledWith(productResponse);
   });

packages/commercetools/composables/__tests__/useUser/factoryParams.spec.ts

@@ -1,10 +1,8 @@
 import { params } from '../../src/useUser/factoryParams';
 import { authenticate } from '../../src/useUser/authenticate';
-import { useCart } from '../../src/useCart';
+import useCart from '../../src/useCart';
 
-jest.mock('../../src/useCart', () => ({
-  useCart: jest.fn(() => {})
-}));
+jest.mock('../../src/useCart', () => jest.fn(() => {}));
 
 jest.mock('../../src/useUser/authenticate', () => ({
   authenticate: jest.fn()

packages/commercetools/composables/__tests__/useUser/index.spec.ts

@@ -1,5 +1,5 @@
 jest.mock('@vue-storefront/core', () => ({
-  useUserFactory: jest.fn(() => ({ useUser: () => ({ user: 'api'}) }))
+  useUserFactory: jest.fn(() => () => ({ user: 'api'}))
 }));
 
 jest.mock('../../src/useUser/factoryParams', () => ({
@@ -8,7 +8,7 @@ jest.mock('../../src/useUser/factoryParams', () => ({
 
 import { useUserFactory } from '@vue-storefront/core';
 import { params } from '../../src/useUser/factoryParams';
-import { useUser } from '../../src/useUser';
+import useUser from '../../src/useUser';
 
 describe('[commercetools-composables] useUser', () => {
   it('returns useUserFactory functions', () => {

packages/commercetools/composables/__tests__/useUserOrders/useUserOrders.spec.ts

@@ -38,10 +38,7 @@ describe('[commercetools-composables] useUserOrders', () => {
 
     const response = await search(context, { param: 'param1' });
 
-    expect(response).toEqual({
-      data: ['order1', 'order2', 'order3'],
-      total: 3
-    });
+    expect(response).toEqual(['order1', 'order2', 'order3']);
     expect(context.$ct.api.getOrders).toBeCalledWith({ param: 'param1' }, undefined);
   });
 
@@ -50,10 +47,7 @@ describe('[commercetools-composables] useUserOrders', () => {
 
     const response = await search(context);
 
-    expect(response).toEqual({
-      data: ['order1', 'order2', 'order3'],
-      total: 3
-    });
+    expect(response).toEqual(['order1', 'order2', 'order3']);
     expect(context.$ct.api.getOrders).toBeCalled();
   });
 
@@ -64,10 +58,7 @@ describe('[commercetools-composables] useUserOrders', () => {
 
     const response = await search(context, { param: 'param1' });
 
-    expect(response).toEqual({
-      data: [],
-      total: 0
-    });
+    expect(response).toEqual([]);
     expect(context.$ct.api.getOrders).toBeCalledWith({ param: 'param1' }, undefined);
   });
 });

packages/commercetools/composables/src/index.ts

@@ -2,9 +2,9 @@
 
 import useCategory from './useCategory';
 import useProduct from './useProduct';
-import { useCart } from './useCart';
+import useCart from './useCart';
 import useCheckout from './useCheckout';
-import { useUser } from './useUser';
+import useUser from './useUser';
 import useUserOrders from './useUserOrders';
 import { useReview } from './useReview';
 import useFacet from './useFacet';

packages/commercetools/composables/src/useCart/index.ts

@@ -67,6 +67,4 @@ const params: UseCartFactoryParams<Cart, LineItem, ProductVariant, AgnosticCoupo
   }
 };
 
-const { useCart } = useCartFactory<Cart, LineItem, ProductVariant, AgnosticCoupon>(params);
-
-export { useCart };
+export default useCartFactory<Cart, LineItem, ProductVariant, AgnosticCoupon>(params);

packages/commercetools/composables/src/useCheckout/index.ts

@@ -8,7 +8,7 @@ import createSetPersonalDetails from './createSetPersonalDetails';
 import createSetPaymentMethod from './createSetPaymentMethod';
 import createPlaceOrder from './createPlaceOrder';
 import createLoadDetails from './createLoadDetails';
-import { useCart } from './../useCart';
+import useCart from './../useCart';
 import initFields from './initFields';
 import { computed } from '@vue/composition-api';
 import { sharedRef, generateContext } from '@vue-storefront/core';
@@ -17,7 +17,7 @@ import { sharedRef, generateContext } from '@vue-storefront/core';
 const useCheckoutFactory = (factoryParams) => {
   const useCheckout = () => {
     const context = generateContext({
-      setup() {
+      provide() {
         return useCart();
       }
     });

packages/commercetools/composables/src/useProduct/index.ts

@@ -1,9 +1,9 @@
 import { ProductsSearchParams } from '../types';
 import { ProductVariant } from './../types/GraphQL';
 import { enhanceProduct, mapPaginationParams } from './../helpers/internals';
-import { useProductFactory, ProductsSearchResult, UseProduct, Context } from '@vue-storefront/core';
+import { useProductFactory, UseProduct, Context } from '@vue-storefront/core';
 
-const productsSearch = async (context: Context, { customQuery, ...searchParams }): Promise<ProductsSearchResult<ProductVariant>> => {
+const productsSearch = async (context: Context, { customQuery, ...searchParams }): Promise<ProductVariant[]> => {
   const apiSearchParams = {
     ...searchParams,
     ...mapPaginationParams(searchParams)
@@ -13,13 +13,10 @@ const productsSearch = async (context: Context, { customQuery, ...searchParams }
   const enhancedProductResponse = enhanceProduct(productResponse);
   const products = (enhancedProductResponse.data as any)._variants;
 
-  return {
-    data: products,
-    total: productResponse.data.products.total
-  };
+  return products;
 };
 
-const useProduct: (cacheId: string) => UseProduct<ProductVariant, ProductsSearchParams> = useProductFactory<ProductVariant, ProductsSearchParams>({
+const useProduct: (cacheId: string) => UseProduct<ProductVariant[], ProductsSearchParams> = useProductFactory<ProductVariant[], ProductsSearchParams>({
   productsSearch
 });
 

packages/commercetools/composables/src/useUser/factoryParams.ts

@@ -1,7 +1,7 @@
 import { CustomQuery, UseUserFactoryParams, Context, UseCart, AgnosticCoupon } from '@vue-storefront/core';
 import { Cart, Customer, LineItem, ProductVariant } from '../types/GraphQL';
 import { authenticate } from './authenticate';
-import { useCart } from '../useCart';
+import useCart from '../useCart';
 
 type UserContext = UseCart<Cart, LineItem, ProductVariant, AgnosticCoupon> & Context;
 
@@ -23,7 +23,7 @@ const getCurrentUser = async (context: Context, currentUser) => {
 };
 
 export const params: UseUserFactoryParams<Customer, any, any> = {
-  setup() {
+  provide() {
     return useCart();
   },
   load,

packages/commercetools/composables/src/useUser/index.ts

@@ -5,6 +5,4 @@ import {
 import { params } from './factoryParams';
 import { useUserFactory } from '@vue-storefront/core';
 
-const { useUser } = useUserFactory<Customer, any, any>(params);
-
-export { useUser };
+export default useUserFactory<Customer, any, any>(params);

packages/commercetools/composables/src/useUserOrders/index.ts

@@ -1,13 +1,13 @@
-import { OrdersSearchResult, useUserOrdersFactory, UseUserOrdersFactoryParams, Context } from '@vue-storefront/core';
+import { useUserOrdersFactory, UseUserOrdersFactoryParams, Context } from '@vue-storefront/core';
 import { Order } from '../types/GraphQL';
 import { OrderSearchParams } from '../types';
 
-const params: UseUserOrdersFactoryParams<Order, OrderSearchParams> = {
-  searchOrders: async (context: Context, { customQuery, ...searchParams } = {}): Promise<OrdersSearchResult<Order>> => {
+const params: UseUserOrdersFactoryParams<Order[], OrderSearchParams> = {
+  searchOrders: async (context: Context, { customQuery, ...searchParams } = {}): Promise<Order[]> => {
     const result = await context.$ct.api.getOrders(searchParams, customQuery);
-    const { results: data, total } = result.data?.me.orders || { results: [], total: 0 };
-    return { data, total };
+    const { results: data } = result.data?.me.orders || { results: [], total: 0 };
+    return data;
   }
 };
 
-export default useUserOrdersFactory<Order, OrderSearchParams>(params);
+export default useUserOrdersFactory<Order[], OrderSearchParams>(params);

packages/core/core/__tests__/factories/useCartFactory.spec.ts

@@ -25,8 +25,7 @@ function createComposable() {
     }),
     isOnCart: jest.fn().mockReturnValueOnce(true)
   };
-  const factory = useCartFactory<any, any, any, any>(params);
-  useCart = factory.useCart;
+  useCart = useCartFactory<any, any, any, any>(params);
 }
 
 describe('[CORE - factories] useCartFactory', () => {

packages/core/core/__tests__/factories/useProductFactory.spec.ts

@@ -2,36 +2,30 @@ import { useProductFactory } from '../../src/factories';
 import { UseProduct } from '../../src/types';
 
 const useProduct: (cacheId: string) => UseProduct<any, any> = useProductFactory<any, any>({
-  productsSearch: (context, searchParams) => Promise.resolve({
-    data: [{ name: 'product ' + searchParams.slug }],
-    total: 1
-  })
+  productsSearch: (context, searchParams) => Promise.resolve([{ name: 'product ' + searchParams.slug }])
 });
 
 describe('[CORE - factories] useProductFactory', () => {
   it('creates properties', () => {
-    const { products, loading, totalProducts } = useProduct('test-product');
+    const { products, loading } = useProduct('test-product');
 
     expect(products.value).toEqual([]);
     expect(loading.value).toEqual(false);
-    expect(totalProducts.value).toEqual(0);
   });
 
   it('returns product response', async () => {
-    const { search, products, totalProducts } = useProduct('test-use-product');
+    const { search, products } = useProduct('test-use-product');
 
     await search({ slug: 'product-slug' });
 
     expect(products.value).toEqual([{name: 'product product-slug' }]);
-    expect(totalProducts.value).toEqual(1);
   });
 
   it('returns product response with ssr', async () => {
-    const { search, products, totalProducts } = useProduct('test-use-product');
+    const { search, products } = useProduct('test-use-product');
 
     await search({ slug: 'product-slug' });
 
     expect(products.value).toEqual([{name: 'product product-slug' }]);
-    expect(totalProducts.value).toEqual(1);
   });
 });

packages/core/core/__tests__/factories/useUserFactory.spec.ts

@@ -11,7 +11,7 @@ const factoryParams = {
   refreshUser: jest.fn()
 };
 
-const { useUser } = useUserFactory(factoryParams);
+const useUser = useUserFactory(factoryParams);
 const useUserMethods = useUser();
 
 describe('[CORE - factories] useUserFactory', () => {
@@ -20,7 +20,7 @@ describe('[CORE - factories] useUserFactory', () => {
   });
   describe('initial setup', () => {
     it('should have proper initial properties', () => {
-      const { useUser } = useUserFactory(factoryParams);
+      const useUser = useUserFactory(factoryParams);
       const { user, isAuthenticated } = useUser();
 
       expect(user.value).toEqual(null);

packages/core/core/__tests__/factories/useUserOrdersFactory.spec.ts

@@ -1,13 +1,13 @@
 import { UseUserOrders } from '../../src/types';
-import { UseUserOrdersFactoryParams, useUserOrdersFactory, OrdersSearchResult } from '../../src/factories';
+import { UseUserOrdersFactoryParams, useUserOrdersFactory } from '../../src/factories';
 import { Ref } from '@vue/composition-api';
 
-let useUserOrders: () => UseUserOrders<Readonly<Ref<Readonly<OrdersSearchResult<any>>>>, any>;
+let useUserOrders: () => UseUserOrders<Readonly<Ref<Readonly<any>>>, any>;
 let params: UseUserOrdersFactoryParams<any, any>;
 
 function createComposable(): void {
   params = {
-    searchOrders: jest.fn().mockResolvedValueOnce({ data: ['first', 'second'], total: 10 })
+    searchOrders: jest.fn().mockResolvedValueOnce(['first', 'second'])
   };
   useUserOrders = useUserOrdersFactory<any, any>(params);
 }
@@ -20,20 +20,18 @@ describe('[CORE - factories] useUserOrderFactory', () => {
 
   describe('initial setup', () => {
     it('should have proper initial props', () => {
-      const { loading, orders, totalOrders } = useUserOrders();
+      const { loading, orders } = useUserOrders();
       expect(loading.value).toEqual(false);
       expect(orders.value).toEqual([]);
-      expect(totalOrders.value).toEqual(0);
     });
   });
 
   describe('methods', () => {
     describe('search', () => {
       it('should set search results', async () => {
-        const { search, orders, totalOrders } = useUserOrders();
+        const { search, orders } = useUserOrders();
         await search({});
         expect(orders.value).toEqual(['first', 'second']);
-        expect(totalOrders.value).toEqual(10);
       });
 
       it('should disable loading flag on error', async () => {

packages/core/core/__tests__/utils/context.spec.ts

@@ -70,7 +70,7 @@ describe('context', () => {
       a: 1
     };
     const factoryParams = {
-      setup () {
+      provide () {
         return {
           b: 2,
           c: 3

packages/core/core/src/factories/useCartFactory.ts

@@ -27,15 +27,10 @@ export interface UseCartFactoryParams<CART, CART_ITEM, PRODUCT, COUPON> extends
   isOnCart: (context: Context, params: { currentCart: CART; product: PRODUCT }) => boolean;
 }
 
-interface UseCartFactory<CART, CART_ITEM, PRODUCT, COUPON> {
-  useCart: () => UseCart<CART, CART_ITEM, PRODUCT, COUPON>;
-}
-
 export const useCartFactory = <CART, CART_ITEM, PRODUCT, COUPON>(
   factoryParams: UseCartFactoryParams<CART, CART_ITEM, PRODUCT, COUPON>
-): UseCartFactory<CART, CART_ITEM, PRODUCT, COUPON> => {
-
-  const useCart = (): UseCart<CART, CART_ITEM, PRODUCT, COUPON> => {
+) => {
+  return function useCart (): UseCart<CART, CART_ITEM, PRODUCT, COUPON> {
     const loading: Ref<boolean> = sharedRef(false, 'useCart-loading');
     const cart: Ref<CART> = sharedRef(null, 'useCart-cart');
     const context = generateContext(factoryParams);
@@ -187,6 +182,4 @@ export const useCartFactory = <CART, CART_ITEM, PRODUCT, COUPON>(
       loading: computed(() => loading.value)
     };
   };
-
-  return { useCart };
 };