@rebilly/instruments 4.5.0 → 4.6.0

package/src/storefront/ready-to-pay.spec.js

@@ -6,70 +6,75 @@ import { fetchReadyToPay } from './ready-to-pay';
 import ReadyToPayModel from './models/ready-to-pay-model';
 import { expectConfigurationError } from 'tests/async-utilities';
 import PaymentMetadataModel from './models/payment-metadata';
-import { paymentMethods } from '@rebilly/api-metadata'
+import { paymentMethods } from '@rebilly/api-metadata';
 
 describe('Storefront API Ready to Pay', () => {
-  it('can fetch ready to pay', async () => {
-    const readyToPayPayload = [
-      {
-        method: 'payment-card',
-        feature: null,
-        brands: ['Visa'],
-        filters: []
-      }
-    ];
-    const options = {
-      websiteId: 'test-website-id',
-      items: [
-        {
-          planId: 'test-plan-id',
-          quantity: 1
-        }
-      ]
-    };
+    it('can fetch ready to pay', async () => {
+        const readyToPayPayload = [
+            {
+                method: 'payment-card',
+                feature: null,
+                brands: ['Visa'],
+                filters: [],
+            },
+        ];
+        const options = {
+            websiteId: 'test-website-id',
+            items: [
+                {
+                    planId: 'test-plan-id',
+                    quantity: 1,
+                },
+            ],
+        };
 
-    const paymentCardMetadata = [...paymentMethods].find(method => method.apiName === 'payment-card');
+        const paymentCardMetadata = [...paymentMethods].find(
+            (method) => method.apiName === 'payment-card',
+        );
 
-    when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(
-      ok(readyToPayPayload)
-    );
+        when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(
+            ok(readyToPayPayload),
+        );
 
-    const instance = StorefontTestingInstance({
-      options
-    });
+        const instance = StorefontTestingInstance({
+            options,
+        });
 
-    vi.spyOn(instance.storefront.purchase, 'readyToPay');
+        vi.spyOn(instance.storefront.purchase, 'readyToPay');
 
-    const riskMetadata = null;
-    const response = await fetchReadyToPay({ state: instance, riskMetadata });
+        const riskMetadata = null;
+        const response = await fetchReadyToPay({
+            state: instance,
+            riskMetadata,
+        });
 
-    expect(instance.storefront.purchase.readyToPay).toBeCalledTimes(1);
-    expect(instance.storefront.purchase.readyToPay).toBeCalledWith({
-      data: expect.objectContaining({
-        items: options.items,
-        websiteId: options.websiteId,
-        riskMetadata: expect.anything()
-      })
+        expect(instance.storefront.purchase.readyToPay).toBeCalledTimes(1);
+        expect(instance.storefront.purchase.readyToPay).toBeCalledWith({
+            data: expect.objectContaining({
+                items: options.items,
+                websiteId: options.websiteId,
+                riskMetadata: expect.anything(),
+            }),
+        });
+        expect(response).toBeInstanceOf(Array);
+        expect(response[0]).toBeInstanceOf(ReadyToPayModel);
+        expect(response).toEqual([
+            new ReadyToPayModel({
+                index: 0,
+                ...readyToPayPayload[0],
+                metadata: new PaymentMetadataModel(paymentCardMetadata),
+            }),
+        ]);
     });
-    expect(response).toBeInstanceOf(Array);
-    expect(response[0]).toBeInstanceOf(ReadyToPayModel);
-    expect(response).toEqual([
-      new ReadyToPayModel({
-        index: 0,
-        ...readyToPayPayload[0],
-        metadata: new PaymentMetadataModel(paymentCardMetadata),
-      })
-    ]);
-  });
 
-  it('should throw errors with no options', async () => {
-    const riskMetadata = null;
+    it('should throw errors with no options', async () => {
+        const riskMetadata = null;
 
-    const noConfigOrOptionsInstance = new StorefontTestingInstance({
-      options: null
+        const noConfigOrOptionsInstance = new StorefontTestingInstance({
+            options: null,
+        });
+        await expectConfigurationError(
+            fetchReadyToPay({ riskMetadata, state: noConfigOrOptionsInstance }),
+        );
     });
-    await expectConfigurationError(
-      fetchReadyToPay({ riskMetadata, state: noConfigOrOptionsInstance })
-    );
-  });
 });

package/src/storefront/storefront.spec.js

@@ -1,14 +1,14 @@
 import { MockStorefront } from 'tests/mocks/storefront-mock';
 
 describe('Storefront application programming interface', () => {
-  it('can create rebilly-js-sdk instance', () => {
-    const storefront = MockStorefront();
-    expect(storefront).toHaveProperty('setPublishableKey');
-  });
+    it('can create rebilly-js-sdk instance', () => {
+        const storefront = MockStorefront();
+        expect(storefront).toHaveProperty('setPublishableKey');
+    });
 
-  it('has required endpoints', () => {
-    const storefront = MockStorefront();
-    expect(storefront).toHaveProperty('purchase');
-    expect(storefront.purchase).toHaveProperty('readyToPay');
-  });
+    it('has required endpoints', () => {
+        const storefront = MockStorefront();
+        expect(storefront).toHaveProperty('purchase');
+        expect(storefront.purchase).toHaveProperty('readyToPay');
+    });
 });

package/src/storefront/summary.js

@@ -2,87 +2,113 @@ import cloneDeep from 'lodash.clonedeep';
 import state from '../state';
 import SummaryModel from './models/summary-model';
 import { Endpoint } from './index';
-import { mapItemsQuantities, createQuantitiesMap, updateItemQuantityFromMap } from '../utils/quantity';
+import {
+    mapItemsQuantities,
+    createQuantitiesMap,
+    updateItemQuantityFromMap,
+} from '../utils/quantity';
 
 export async function fetchSummary({ data = null } = {}) {
-  return Endpoint(async () => {
-    const items = state.options?.items;
-    const websiteId = state.options?.websiteId || null;
-    const bumpOfferProductsIds = state.options?.bumpOffer?.map(({ planId }) => planId) || [];
+    return Endpoint(async () => {
+        const items = state.options?.items;
+        const websiteId = state.options?.websiteId || null;
+        const bumpOfferProductsIds =
+            state.options?.bumpOffer?.map(({ planId }) => planId) || [];
 
-    const payload = {
-      data: {
-        websiteId
-      }
-    };
+        const payload = {
+            data: {
+                websiteId,
+            },
+        };
 
-    const isBumpOfferSummary = () => state.data.summaryLineItems.every(
-      item => bumpOfferProductsIds.includes(item.planId)
-    );
-    if (!isBumpOfferSummary() && !state.data.acceptBumpOffer) {
-      payload.data.items = mapItemsQuantities(state.data.summaryLineItems);
-    } else if (items) {
-      if (state.data.acceptBumpOffer) {
-        payload.data.items = state.options.bumpOffer;
-      } else {
-        payload.data.items = mapItemsQuantities(items);
-      }
-    } else {
-      payload.data.items = mapItemsQuantities(state.data.summaryLineItems);
+        const isBumpOfferSummary = () =>
+            state.data.summaryLineItems.every((item) =>
+                bumpOfferProductsIds.includes(item.planId),
+            );
+        if (!isBumpOfferSummary() && !state.data.acceptBumpOffer) {
+            payload.data.items = mapItemsQuantities(
+                state.data.summaryLineItems,
+            );
+        } else if (items) {
+            if (state.data.acceptBumpOffer) {
+                payload.data.items = state.options.bumpOffer;
+            } else {
+                payload.data.items = mapItemsQuantities(items);
+            }
+        } else {
+            payload.data.items = mapItemsQuantities(
+                state.data.summaryLineItems,
+            );
 
-      if (state.data?.addons.length > 0) {
-        payload.data.items = payload.data.items.concat(state.data.addons.map(mapItemsQuantities))
-      }
-    }
+            if (state.data?.addons.length > 0) {
+                payload.data.items = payload.data.items.concat(
+                    state.data.addons.map(mapItemsQuantities),
+                );
+            }
+        }
 
-    if (!state.data.acceptBumpOffer && state.data?.previewPurchase?.addonLineItems?.length > 0) {
-      payload.data.items = payload.data.items.concat(state.data.previewPurchase.addonLineItems);
-    }
+        if (
+            !state.data.acceptBumpOffer &&
+            state.data?.previewPurchase?.addonLineItems?.length > 0
+        ) {
+            payload.data.items = payload.data.items.concat(
+                state.data.previewPurchase.addonLineItems,
+            );
+        }
 
-    if (state.data?.amountAndCurrency) {
-      payload.data = {
-        ...payload.data,
-        ...state.data.amountAndCurrency
-      }
-    }
+        if (state.data?.amountAndCurrency) {
+            payload.data = {
+                ...payload.data,
+                ...state.data.amountAndCurrency,
+            };
+        }
 
-    if (data?.billingAddress) {
-      payload.data.billingAddress = data.billingAddress;
-    }
+        if (data?.billingAddress) {
+            payload.data.billingAddress = data.billingAddress;
+        }
 
-    if (data?.deliveryAddress) {
-      payload.data.deliveryAddress = data.deliveryAddress;
-    }
+        if (data?.deliveryAddress) {
+            payload.data.deliveryAddress = data.deliveryAddress;
+        }
 
-    if (state.data?.couponIds) {
-      payload.data.couponIds = state.data.couponIds;
-    }
+        if (state.data?.couponIds) {
+            payload.data.couponIds = state.data.couponIds;
+        }
 
-    const { fields: summaryFields } = await state.storefront.purchase.preview(
-      payload
-    );
+        const { fields: summaryFields } =
+            await state.storefront.purchase.preview(payload);
 
-    let transformedFields = summaryFields;
-    if (!state.data.acceptBumpOffer) {
-      const quantitiesByPlanId = createQuantitiesMap(items);
+        let transformedFields = summaryFields;
+        if (!state.data.acceptBumpOffer) {
+            const quantitiesByPlanId = createQuantitiesMap(items);
 
-      transformedFields = cloneDeep(summaryFields);
-      if (transformedFields.lineItems) {
-        if (state.data?.previewPurchase?.addonLineItems) {
-          const addonsMap = state.data.previewPurchase.addonLineItems.reduce((map, curr) => {
-            map.set(curr.planId, curr);
-            return map;
-          }, new Map());
-          transformedFields.lineItems = transformedFields.lineItems.filter(item => !addonsMap.has(item.planId));
-          transformedFields.addonLineItems = state.data.previewPurchase.addonLineItems;
+            transformedFields = cloneDeep(summaryFields);
+            if (transformedFields.lineItems) {
+                if (state.data?.previewPurchase?.addonLineItems) {
+                    const addonsMap =
+                        state.data.previewPurchase.addonLineItems.reduce(
+                            (map, curr) => {
+                                map.set(curr.planId, curr);
+                                return map;
+                            },
+                            new Map(),
+                        );
+                    transformedFields.lineItems =
+                        transformedFields.lineItems.filter(
+                            (item) => !addonsMap.has(item.planId),
+                        );
+                    transformedFields.addonLineItems =
+                        state.data.previewPurchase.addonLineItems;
+                }
+                transformedFields.lineItems.forEach(
+                    updateItemQuantityFromMap(quantitiesByPlanId),
+                );
+            }
         }
-        transformedFields.lineItems.forEach(updateItemQuantityFromMap(quantitiesByPlanId))
-      }
-    }
 
-    // In case of preview purchase gets call again for updating the values
-    state.data.previewPurchase = transformedFields;
+        // In case of preview purchase gets call again for updating the values
+        state.data.previewPurchase = transformedFields;
 
-    return new SummaryModel(transformedFields);
-  });
+        return new SummaryModel(transformedFields);
+    });
 }

package/src/storefront/summary.spec.js

@@ -7,128 +7,130 @@ import { expectConfigurationError } from 'tests/async-utilities';
 import { fetchSummary } from './summary';
 
 describe('Storefront API Summary', () => {
-  it('can fetch preview', async () => {
-    const options = {
-      websiteId: 'test-website-id',
-      items: [
-        {
-          planId: 'test-plan-id',
-          quantity: 1
-        }
-      ]
-    };
-    const testSummary = {
-      currency: 'USD',
-      lineItems: [
-        {
-          description: 'test-plan-id-1',
-          planId: 'test-plan-id-1',
-          quantity: 1
-        }
-      ]
-    };
+    it('can fetch preview', async () => {
+        const options = {
+            websiteId: 'test-website-id',
+            items: [
+                {
+                    planId: 'test-plan-id',
+                    quantity: 1,
+                },
+            ],
+        };
+        const testSummary = {
+            currency: 'USD',
+            lineItems: [
+                {
+                    description: 'test-plan-id-1',
+                    planId: 'test-plan-id-1',
+                    quantity: 1,
+                },
+            ],
+        };
 
-    when(post(`${storefrontURL}/preview-purchase`)).thenReturn(ok(testSummary));
+        when(post(`${storefrontURL}/preview-purchase`)).thenReturn(
+            ok(testSummary),
+        );
 
-    const instance = StorefontTestingInstance({
-      options
-    });
+        const instance = StorefontTestingInstance({
+            options,
+        });
 
-    vi.spyOn(instance.storefront.purchase, 'preview');
+        vi.spyOn(instance.storefront.purchase, 'preview');
 
-    const response = await fetchSummary({ state: instance });
+        const response = await fetchSummary({ state: instance });
 
-    expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
-    expect(instance.storefront.purchase.preview).toBeCalledWith({
-      data: expect.objectContaining({
-        items: options.items,
-        websiteId: options.websiteId
-      })
+        expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
+        expect(instance.storefront.purchase.preview).toBeCalledWith({
+            data: expect.objectContaining({
+                items: options.items,
+                websiteId: options.websiteId,
+            }),
+        });
+        expect(response).toBeInstanceOf(SummaryModel);
+        expect(response).toEqual(new SummaryModel(testSummary));
     });
-    expect(response).toBeInstanceOf(SummaryModel);
-    expect(response).toEqual(new SummaryModel(testSummary));
-  });
 
-  it('Adds billing address to preview payload', async () => {
-    const options = {
-      websiteId: 'test-website-id',
-      items: [
-        {
-          planId: 'test-plan-id',
-          quantity: 1
-        }
-      ]
-    };
-    const billingAddress = {
-      firstName: 'Test',
-      lastName: 'Customer'
-    };
-    const instance = StorefontTestingInstance({
-      options
-    });
+    it('Adds billing address to preview payload', async () => {
+        const options = {
+            websiteId: 'test-website-id',
+            items: [
+                {
+                    planId: 'test-plan-id',
+                    quantity: 1,
+                },
+            ],
+        };
+        const billingAddress = {
+            firstName: 'Test',
+            lastName: 'Customer',
+        };
+        const instance = StorefontTestingInstance({
+            options,
+        });
 
-    vi.spyOn(instance.storefront.purchase, 'preview');
+        vi.spyOn(instance.storefront.purchase, 'preview');
 
-    await fetchSummary({
-      data: {
-        billingAddress
-      },
-      state: instance
-    });
+        await fetchSummary({
+            data: {
+                billingAddress,
+            },
+            state: instance,
+        });
 
-    expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
-    expect(instance.storefront.purchase.preview).toBeCalledWith({
-      data: expect.objectContaining({
-        items: options.items,
-        websiteId: options.websiteId,
-        billingAddress
-      })
+        expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
+        expect(instance.storefront.purchase.preview).toBeCalledWith({
+            data: expect.objectContaining({
+                items: options.items,
+                websiteId: options.websiteId,
+                billingAddress,
+            }),
+        });
     });
-  });
 
-  it('Adds delivery address to preview payload', async () => {
-    const options = {
-      websiteId: 'test-website-id',
-      items: [
-        {
-          planId: 'test-plan-id',
-          quantity: 1
-        }
-      ]
-    };
-    const deliveryAddress = {
-      firstName: 'Test',
-      lastName: 'Customer'
-    };
-    const instance = StorefontTestingInstance({
-      options
-    });
+    it('Adds delivery address to preview payload', async () => {
+        const options = {
+            websiteId: 'test-website-id',
+            items: [
+                {
+                    planId: 'test-plan-id',
+                    quantity: 1,
+                },
+            ],
+        };
+        const deliveryAddress = {
+            firstName: 'Test',
+            lastName: 'Customer',
+        };
+        const instance = StorefontTestingInstance({
+            options,
+        });
 
-    vi.spyOn(instance.storefront.purchase, 'preview');
+        vi.spyOn(instance.storefront.purchase, 'preview');
 
-    await fetchSummary({
-      data: {
-        deliveryAddress
-      },
-      state: instance
-    });
+        await fetchSummary({
+            data: {
+                deliveryAddress,
+            },
+            state: instance,
+        });
 
-    expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
-    expect(instance.storefront.purchase.preview).toBeCalledWith({
-      data: expect.objectContaining({
-        items: options.items,
-        websiteId: options.websiteId,
-        deliveryAddress
-      })
+        expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
+        expect(instance.storefront.purchase.preview).toBeCalledWith({
+            data: expect.objectContaining({
+                items: options.items,
+                websiteId: options.websiteId,
+                deliveryAddress,
+            }),
+        });
     });
-  });
 
-  it('should throw errors with no options', async () => {
-    const noConfigOrOptionsInstance = StorefontTestingInstance({
-      options: null
+    it('should throw errors with no options', async () => {
+        const noConfigOrOptionsInstance = StorefontTestingInstance({
+            options: null,
+        });
+        await expectConfigurationError(
+            fetchSummary({ state: noConfigOrOptionsInstance }),
+        );
     });
-    await expectConfigurationError(
-      fetchSummary({ state: noConfigOrOptionsInstance })
-    );
-  });
 });

package/src/storefront/transactions.js

@@ -3,10 +3,10 @@ import { Endpoint } from './index';
 import state from '../state';
 
 export async function fetchTransaction({ data = null }) {
-  return Endpoint(async () => {
-    state.storefront.setSessionToken(state.options.jwt);
-    const {fields} = await state.storefront.transactions.get(data);
+    return Endpoint(async () => {
+        state.storefront.setSessionToken(state.options.jwt);
+        const { fields } = await state.storefront.transactions.get(data);
 
-    return new TransactionModel(fields);
-  });
-}
+        return new TransactionModel(fields);
+    });
+}