feat(payment): PAYPAL-4935 changes related to gql logic

Author: bc-nick

packages/core/src/cart/cart-action-creator.spec.ts

@@ -12,6 +12,7 @@ import CartActionCreator from './cart-action-creator';
 import { CartActionType } from './cart-actions';
 import CartRequestSender from './cart-request-sender';
 import { getCart } from './carts.mock';
+import { getGQLCartResponse, getGQLCurrencyResponse } from './gql-cart/mocks/gql-cart.mock';
 
 describe('CartActionCreator', () => {
     let cartActionCreator: CartActionCreator;
@@ -29,7 +30,11 @@ describe('CartActionCreator', () => {
         store = createCheckoutStore(getCheckoutStoreState());
 
         jest.spyOn(cartRequestSender, 'loadCart').mockReturnValue(
-            Promise.resolve(getResponse(getCart())),
+            Promise.resolve(getResponse(getGQLCartResponse())),
+        );
+
+        jest.spyOn(cartRequestSender, 'loadCartCurrency').mockReturnValue(
+            Promise.resolve(getResponse(getGQLCurrencyResponse())),
         );
 
         cartActionCreator = new CartActionCreator(cartRequestSender);
@@ -47,7 +52,29 @@ describe('CartActionCreator', () => {
                 { type: CartActionType.LoadCartRequested },
                 {
                     type: CartActionType.LoadCartSucceeded,
-                    payload: getCart(),
+                    payload: expect.objectContaining({
+                        id: cart.id,
+                        currency: {
+                            code: cart.currency.code,
+                            name: cart.currency.name,
+                            symbol: cart.currency.symbol,
+                            decimalPlaces: cart.currency.decimalPlaces,
+                        },
+                        lineItems: expect.objectContaining({
+                            physicalItems: cart.lineItems.physicalItems.map((item) =>
+                                expect.objectContaining({
+                                    id: item.id,
+                                    variantId: item.variantId,
+                                    productId: item.productId,
+                                    sku: item.sku,
+                                    name: item.name,
+                                    url: item.url,
+                                    quantity: item.quantity,
+                                    isShippingRequired: item.isShippingRequired,
+                                }),
+                            ),
+                        }),
+                    }),
                 },
             ]),
         );

packages/core/src/cart/cart-action-creator.ts

@@ -1,4 +1,6 @@
 import { createAction, createErrorAction, ThunkAction } from '@bigcommerce/data-store';
+import { Response } from '@bigcommerce/request-sender';
+import { merge } from 'lodash';
 import { Observable, Observer } from 'rxjs';
 
 import { RequestOptions } from '@bigcommerce/checkout-sdk/payment-integration-api';
@@ -7,8 +9,10 @@ import { InternalCheckoutSelectors } from '../checkout';
 import { cachableAction } from '../common/data-store';
 import ActionOptions from '../common/data-store/action-options';
 
+import Cart from './cart';
 import { CartActionType, LoadCartAction } from './cart-actions';
 import CartRequestSender from './cart-request-sender';
+import { GQLCartResponse, GQLCurrencyResponse, GQLRequestResponse, mapToCart } from './gql-cart';
 
 export default class CartActionCreator {
     constructor(private _cartRequestSender: CartRequestSender) {}
@@ -19,24 +23,49 @@ export default class CartActionCreator {
         options?: RequestOptions & ActionOptions,
     ): ThunkAction<LoadCartAction, InternalCheckoutSelectors> {
         return (store) => {
-            return Observable.create((observer: Observer<LoadCartAction>) => {
+            return new Observable((observer: Observer<LoadCartAction>) => {
                 const state = store.getState();
-                const host = state.config.getHost();
+                const gqlUrl = state.config.getGQLRequestUrl();
 
                 observer.next(createAction(CartActionType.LoadCartRequested, undefined));
 
                 this._cartRequestSender
-                    .loadCart(cartId, host, options)
-                    .then((response) => {
-                        observer.next(
-                            createAction(CartActionType.LoadCartSucceeded, response.body),
-                        );
-                        observer.complete();
+                    .loadCart(cartId, gqlUrl, options)
+                    .then((cartResponse) => {
+                        return this._cartRequestSender
+                            .loadCartCurrency(
+                                cartResponse.body.data.site.cart.currencyCode,
+                                gqlUrl,
+                                options,
+                            )
+                            .then((currencyResponse) => {
+                                observer.next(
+                                    createAction(
+                                        CartActionType.LoadCartSucceeded,
+                                        this.transformToCartResponse(
+                                            merge(cartResponse, currencyResponse),
+                                        ),
+                                    ),
+                                );
+                                observer.complete();
+                            });
                     })
                     .catch((response) => {
                         observer.error(createErrorAction(CartActionType.LoadCartFailed, response));
                     });
             });
         };
     }
+
+    private transformToCartResponse(
+        response: Response<GQLRequestResponse<GQLCartResponse & GQLCurrencyResponse>>,
+    ): Cart {
+        const {
+            body: {
+                data: { site },
+            },
+        } = response;
+
+        return mapToCart(site);
+    }
 }

packages/core/src/cart/cart-request-sender.spec.ts

@@ -7,22 +7,26 @@ import {
 
 import { CartSource } from '@bigcommerce/checkout-sdk/payment-integration-api';
 
+import { GQL_REQUEST_URL } from '../common/gql-request';
 import { ContentType, SDK_VERSION_HEADERS } from '../common/http-request';
 import { getResponse } from '../common/http-request/responses.mock';
 
 import BuyNowCartRequestBody from './buy-now-cart-request-body';
 import Cart from './cart';
 import CartRequestSender from './cart-request-sender';
 import { getCart } from './carts.mock';
-import { GQLCartRequestResponse } from './gql-cart';
-import { getGQLCartResponse } from './gql-cart/mocks/gql-cart.mock';
+import { GQLCartResponse, GQLCurrencyResponse, GQLRequestResponse } from './gql-cart';
+import getCartCurrencyQuery from './gql-cart/get-cart-currency-query';
+import getCartQuery from './gql-cart/get-cart-query';
+import { getGQLCartResponse, getGQLCurrencyResponse } from './gql-cart/mocks/gql-cart.mock';
 
 describe('CartRequestSender', () => {
     let cart: Cart;
     let cartRequestSender: CartRequestSender;
     let requestSender: RequestSender;
     let response: Response<Cart>;
-    let headlessResponse: Response<GQLCartRequestResponse>;
+    let gqlResponse: Response<GQLRequestResponse<GQLCartResponse>>;
+    let gqlCurrencyResponse: Response<GQLRequestResponse<GQLCurrencyResponse>>;
 
     beforeEach(() => {
         requestSender = createRequestSender();
@@ -81,24 +85,63 @@ describe('CartRequestSender', () => {
 
     describe('#loadCart', () => {
         const cartId = '123123';
+        const gqlUrl = 'https://test.com/graphql';
 
         beforeEach(() => {
-            headlessResponse = getResponse(getGQLCartResponse());
+            gqlResponse = getResponse(getGQLCartResponse());
 
-            jest.spyOn(requestSender, 'get').mockResolvedValue(headlessResponse);
+            jest.spyOn(requestSender, 'post').mockResolvedValue(gqlResponse);
         });
 
-        it('get headless cart', async () => {
+        it('get gql cart', async () => {
             await cartRequestSender.loadCart(cartId);
 
-            expect(requestSender.get).toHaveBeenCalledWith(
-                'http://localhost/api/wallet-buttons/cart-information',
-                {
-                    params: {
-                        cartId,
-                    },
+            expect(requestSender.post).toHaveBeenCalledWith(GQL_REQUEST_URL, {
+                body: {
+                    query: getCartQuery(cartId),
+                },
+            });
+        });
+
+        it('get gql cart with graphql url', async () => {
+            await cartRequestSender.loadCart(cartId, gqlUrl);
+
+            expect(requestSender.post).toHaveBeenCalledWith('https://test.com/graphql', {
+                body: {
+                    query: getCartQuery(cartId),
+                },
+            });
+        });
+    });
+
+    describe('#loadCartCurrency', () => {
+        const currencyCode = 'USD';
+        const gqlUrl = 'https://test.com/graphql';
+
+        beforeEach(() => {
+            gqlCurrencyResponse = getResponse(getGQLCurrencyResponse());
+
+            jest.spyOn(requestSender, 'post').mockResolvedValue(gqlCurrencyResponse);
+        });
+
+        it('get gql cart currency', async () => {
+            await cartRequestSender.loadCartCurrency(currencyCode);
+
+            expect(requestSender.post).toHaveBeenCalledWith(GQL_REQUEST_URL, {
+                body: {
+                    query: getCartCurrencyQuery(currencyCode),
                 },
-            );
+            });
+        });
+
+        it('get gql cart currency with host url', async () => {
+            await cartRequestSender.loadCartCurrency(currencyCode, gqlUrl);
+
+            expect(requestSender.post).toHaveBeenCalledWith('https://test.com/graphql', {
+                body: {
+                    query: getCartCurrencyQuery(currencyCode),
+                },
+            });
         });
     });
 });

packages/core/src/cart/cart-request-sender.ts

@@ -2,9 +2,18 @@ import { RequestSender, Response } from '@bigcommerce/request-sender';
 
 import { BuyNowCartRequestBody, Cart } from '@bigcommerce/checkout-sdk/payment-integration-api';
 
+import { GQL_REQUEST_URL } from '../common/gql-request';
 import { ContentType, RequestOptions, SDK_VERSION_HEADERS } from '../common/http-request';
 
-import { GQLCartRequestResponse, mapToCart } from './gql-cart';
+import {
+    GQLCartResponse,
+    GQLCurrencyResponse,
+    GQLRequestOptions,
+    GQLRequestResponse,
+} from './gql-cart';
+import CartRetrievalError from './gql-cart/errors/cart-retrieval-error';
+import getCartCurrencyQuery from './gql-cart/get-cart-currency-query';
+import getCartQuery from './gql-cart/get-cart-query';
 
 export default class CartRequestSender {
     constructor(private _requestSender: RequestSender) {}
@@ -22,40 +31,52 @@ export default class CartRequestSender {
         return this._requestSender.post(url, { body, headers, timeout });
     }
 
-    async loadCart(
-        cartId: string,
-        host?: string,
-        options?: RequestOptions,
-    ): Promise<Response<Cart | undefined>> {
-        const path = 'api/wallet-buttons/cart-information';
-        const url = host ? `${host}/${path}` : `${window.location.origin}/${path}`;
+    async loadCart(cartId: string, gqlUrl?: string, options?: RequestOptions) {
+        const url = gqlUrl ?? GQL_REQUEST_URL;
 
-        const requestOptions: RequestOptions = {
+        const requestOptions: GQLRequestOptions = {
             ...options,
-            params: {
-                cartId,
+            body: {
+                query: getCartQuery(cartId),
             },
         };
 
-        const response = await this._requestSender.get<GQLCartRequestResponse>(url, {
+        const response = await this._requestSender.post<GQLRequestResponse<GQLCartResponse>>(url, {
             ...requestOptions,
         });
 
-        return this.transformToCartResponse(response);
+        if (!response.body.data.site.cart) {
+            throw new CartRetrievalError(
+                `Could not retrieve cart information by cartId: ${cartId}`,
+            );
+        }
+
+        return response;
     }
 
-    private transformToCartResponse(
-        response: Response<GQLCartRequestResponse>,
-    ): Response<Cart | undefined> {
-        const {
+    async loadCartCurrency(currencyCode: string, gqlUrl?: string, options?: RequestOptions) {
+        const url = gqlUrl ?? GQL_REQUEST_URL;
+
+        const requestOptions: GQLRequestOptions = {
+            ...options,
             body: {
-                data: { site },
+                query: getCartCurrencyQuery(currencyCode),
             },
-        } = response;
-
-        return {
-            ...response,
-            body: mapToCart(site),
         };
+
+        const response = await this._requestSender.post<GQLRequestResponse<GQLCurrencyResponse>>(
+            url,
+            {
+                ...requestOptions,
+            },
+        );
+
+        if (!response.body.data.site.currency) {
+            throw new CartRetrievalError(
+                `Could not retrieve currency information by currencyCode: ${currencyCode}`,
+            );
+        }
+
+        return response;
     }
 }

packages/core/src/cart/gql-cart/errors/cart-retrieval-error.spec.ts

@@ -0,0 +1,21 @@
+import CartRetrievalError from './cart-retrieval-error';
+
+describe('init', () => {
+    it('sets type to cart_retrieval', () => {
+        const error = new CartRetrievalError();
+
+        expect(error.type).toBe('cart_retrieval');
+    });
+
+    it('returns error name', () => {
+        const error = new CartRetrievalError();
+
+        expect(error.name).toBe('CartRetrievalError');
+    });
+
+    it('sets the message as `body.title`', () => {
+        const error = new CartRetrievalError('test message');
+
+        expect(error.message).toBe('test message');
+    });
+});

packages/core/src/cart/gql-cart/errors/cart-retrieval-error.ts

@@ -0,0 +1,10 @@
+import { StandardError } from '../../../common/error/errors';
+
+export default class CartRetrievalError extends StandardError {
+    constructor(message?: string) {
+        super(message || 'Cart not available.');
+
+        this.name = 'CartRetrievalError';
+        this.type = 'cart_retrieval';
+    }
+}

packages/core/src/cart/gql-cart/get-cart-currency-query.ts

@@ -0,0 +1,18 @@
+const getCartCurrencyQuery = (currencyCode: string) => {
+    return `
+        query Currency {
+            site {
+                currency(currencyCode: ${currencyCode}) {
+                    display {
+                        decimalPlaces
+                        symbol
+                    }
+                    name
+                    code
+                }
+            }
+        }
+    `;
+};
+
+export default getCartCurrencyQuery;