@rebilly/instruments 1.0.2-beta.8 → 2.1.1-beta.0

package/src/functions/destroy.spec.js

@@ -11,54 +11,53 @@ describe('RebillyInstruments Destroy', () => {
 
     expect(formElement.innerHTML).not.toEqual('');
     expect(summaryElement.innerHTML).not.toEqual('');
-    
+
     await rebillyInstruments.destroy();
-    
+
     expect(formElement.innerHTML).toEqual('');
     expect(summaryElement.innerHTML).toEqual('');
   });
 
+  it('should remove registered listeners', async () => {
+    const rebillyInstruments = await RenderMockRebillyInstruments();
+
+    const fakeEventListener = jest.fn();
+    Events.fakeEvent = new BaseEvent('fake-event');
+    publicEventNames.push('fake-event');
+    rebillyInstruments.on('fake-event', fakeEventListener);
+
+    Events.fakeEvent.dispatch();
+
+    expect(fakeEventListener).toHaveBeenCalledTimes(1);
 
-  it('should remove registered listeners', async ()=> {
+    fakeEventListener.mockClear();
+    await rebillyInstruments.destroy();
+
+    Events.fakeEvent.dispatch();
+    expect(fakeEventListener).not.toHaveBeenCalled();
+  });
+
+  it('should remove multiple listeners on the same event', async () => {
     const rebillyInstruments = await RenderMockRebillyInstruments();
-    
+
     const fakeEventListener = jest.fn();
+    const anotherFakeEventListener = jest.fn();
     Events.fakeEvent = new BaseEvent('fake-event');
     publicEventNames.push('fake-event');
     rebillyInstruments.on('fake-event', fakeEventListener);
+    rebillyInstruments.on('fake-event', anotherFakeEventListener);
 
     Events.fakeEvent.dispatch();
-    
+
     expect(fakeEventListener).toHaveBeenCalledTimes(1);
-    
+    expect(anotherFakeEventListener).toHaveBeenCalledTimes(1);
+
     fakeEventListener.mockClear();
+    anotherFakeEventListener.mockClear();
     await rebillyInstruments.destroy();
-    
+
     Events.fakeEvent.dispatch();
     expect(fakeEventListener).not.toHaveBeenCalled();
-  })
-
-  it('should remove multiple listeners on the same event', async ()=> {
-      const rebillyInstruments = await RenderMockRebillyInstruments();
-      
-      const fakeEventListener = jest.fn();
-      const anotherFakeEventListener = jest.fn();
-      Events.fakeEvent = new BaseEvent('fake-event');
-      publicEventNames.push('fake-event');
-      rebillyInstruments.on('fake-event', fakeEventListener);
-      rebillyInstruments.on('fake-event', anotherFakeEventListener);
-  
-      Events.fakeEvent.dispatch();
-      
-      expect(fakeEventListener).toHaveBeenCalledTimes(1);
-      expect(anotherFakeEventListener).toHaveBeenCalledTimes(1);
-      
-      fakeEventListener.mockClear();
-      anotherFakeEventListener.mockClear();
-      await rebillyInstruments.destroy();
-      
-      Events.fakeEvent.dispatch();
-      expect(fakeEventListener).not.toHaveBeenCalled();
-      expect(anotherFakeEventListener).not.toHaveBeenCalled();
+    expect(anotherFakeEventListener).not.toHaveBeenCalled();
   });
 });

package/src/functions/mount/fetch-data.js

@@ -0,0 +1,148 @@
+import { collectData } from '@rebilly/risk-data-collector';
+import { fetchPlans } from '../../storefront/plans';
+import { fetchProducts } from '../../storefront/products';
+import { fetchReadyToPay } from '../../storefront/ready-to-pay';
+import { fetchSummary } from '../../storefront/summary';
+import { fetchInvoice as FetchInvoice } from '../../storefront/invoices';
+import { fetchTransaction as FetchTransaction } from '../../storefront/transactions';
+
+export class DataInstance {
+  constructor({
+    state = {},
+    ...fields
+  } = {}) {
+    Object.entries({
+      ...state.data || {},
+      ...fields
+    }).forEach(([key, value]) => {
+      this[key] = value;
+    });
+
+    this.money = state.options?.money || null;
+  }
+
+  get amountAndCurrency() {
+    let currency;
+    let amount;
+    if (this.previewPurchase) {
+      currency = this.previewPurchase.currency;
+      amount = this.previewPurchase.total;
+    } else if (this.invoice) {
+      currency = this.invoice.currency;
+      amount = this.invoice.amount;
+    } else if (this.transaction) {
+      currency = this.transaction.currency;
+      amount = this.transaction.amount;
+    } else if (this.money) {
+      currency = this.money.currency;
+      amount = this.money.amount;
+    }
+    return {
+      amount,
+      currency
+    }
+  }
+
+  get isPayment() {
+    return (this.invoice || this.transaction || this.money);
+  }
+
+  get isPurchase() {
+    return this.previewPurchase;
+  }
+
+  get summaryItems() {
+    const {
+      discountsAmount = null,
+      shippingAmount = null,
+      subtotalAmount = null,
+      taxAmount = null,
+    } = (this.previewPurchase || this.invoice || {});
+
+    return {
+      discountsAmount,
+      shippingAmount,
+      subtotalAmount,
+      taxAmount
+    }
+  }
+
+  get summaryLineItems() {
+    let lineItems = [];
+    if (this.invoice) {
+      ({
+        items: lineItems = [],
+      } = this.invoice)
+    } else {
+      ({
+        lineItems = [],
+      } = this.previewPurchase || {});
+    }
+
+    return lineItems;
+  }
+}
+
+export async function fetchData({
+  state = null,
+  riskMetadata = null,
+  summaryPayload = null,
+
+  // Dependancy injectable functions
+  fetchInvoice = FetchInvoice,
+  fetchTransaction = FetchTransaction
+}) {
+  try {
+    let transaction = null;
+    if (state.options?.transactionId) {
+      transaction = await fetchTransaction({data: {
+        id: state.options.transactionId
+      }, state});
+      state.data.transaction = transaction;
+    }
+
+    let invoice = null;
+    if (state.options?.invoiceId || state.data?.transaction?.hasInvoice) {
+      invoice = await fetchInvoice({data: {
+        id: state.options?.invoiceId || state.data?.transaction?.invoiceId
+      }, state});
+      state.data.invoice = invoice;
+    }
+
+    if (!riskMetadata) {
+      const { riskMetadata: data } = await collectData();
+      riskMetadata = data;
+    }
+
+    state.data = new DataInstance({
+      state,
+      invoice,
+      transaction,
+      riskMetadata
+    });
+
+    const [readyToPay, previewPurchase] = await Promise.all([
+      state.data?.readyToPay || fetchReadyToPay({ riskMetadata, state }),
+      state.options.items ? fetchSummary({ data: summaryPayload, state }) : null
+    ]);
+
+    const plans = await fetchPlans({ state });
+    state.data.plans = plans;
+    const products = await fetchProducts({ state });
+
+    return new DataInstance({
+      state,
+      readyToPay,
+      previewPurchase,
+      plans,
+      products,
+      invoice,
+      transaction,
+      riskMetadata
+    });
+  } catch(error) {
+    // console.log(error);
+  }
+
+  return new DataInstance({});
+}

package/src/functions/mount/fetch-data.spec.js

@@ -0,0 +1,238 @@
+import { fetchData, DataInstance } from './fetch-data';
+import TransactionModel from '../../storefront/models/transaction-model';
+
+describe('fetchData function', () => {
+  it('Should use correct invoice id for invoiceId', async () => {
+    const mockFetchInvoice = jest.fn();
+    const invoiceId = 'test-invoice-id';
+    const invoiceState = {
+      options: {
+        invoiceId
+      }
+    }
+
+    fetchData({
+      state: invoiceState,
+      fetchInvoice: mockFetchInvoice
+    });
+    
+    expect(mockFetchInvoice).toBeCalledTimes(1);
+    expect(mockFetchInvoice).toBeCalledWith(
+      expect.objectContaining({
+        data:{
+          id: invoiceId
+        }
+      })
+    );
+  });
+
+  it('Should use correct invoice id for transaction with invoiceIds', async () => {
+    const mockFetchInvoice = jest.fn();
+    const invoiceId = 'test-invoice-id';
+    const invoiceState = {
+      options: {},
+      data: {
+        transaction: new TransactionModel({
+          invoiceIds: [invoiceId]
+        }),
+      }
+    }
+
+    fetchData({
+      state: invoiceState,
+      fetchInvoice: mockFetchInvoice
+    });
+    
+    expect(mockFetchInvoice).toBeCalledTimes(1);
+    expect(mockFetchInvoice).toBeCalledWith(
+      expect.objectContaining({
+        data:{
+          id: invoiceId
+        }
+      })
+    );
+  });
+
+  it('Should not fetch invoice for transaction with no invoice Ids', async () => {
+    const mockFetchInvoice = jest.fn();
+    const invoiceState = {
+      options: {},
+      data: {
+        transaction: new TransactionModel({
+          invoiceIds: []
+        }),
+      }
+    }
+
+    fetchData({
+      state: invoiceState,
+      fetchInvoice: mockFetchInvoice
+    });
+    
+    expect(mockFetchInvoice).toBeCalledTimes(0);
+ 
+  });
+});
+
+describe('DataInstance', () => {
+  it ('Should correctly determine amountAndCurrency', () => {
+    const expectedAmountAndCurrency = {
+      amount: 10,
+      currency: 'USD'
+    }
+    let fetchedData =  new DataInstance({
+      state: {
+        options: {
+          money: {
+            ...expectedAmountAndCurrency
+          }
+        }
+      }
+    });
+    expect(fetchedData.amountAndCurrency).toEqual(
+      expect.objectContaining(expectedAmountAndCurrency)
+    );
+
+    fetchedData =  new DataInstance({
+      previewPurchase: {
+        total: expectedAmountAndCurrency.amount,
+        currency: expectedAmountAndCurrency.currency
+      }
+    });
+    expect(fetchedData.amountAndCurrency).toEqual(
+      expect.objectContaining(expectedAmountAndCurrency)
+    );
+
+    fetchedData =  new DataInstance({
+      invoice: {
+        ...expectedAmountAndCurrency
+      }
+    });
+    expect(fetchedData.amountAndCurrency).toEqual(
+      expect.objectContaining(expectedAmountAndCurrency)
+    );
+
+    fetchedData =  new DataInstance({
+      transaction: {
+        ...expectedAmountAndCurrency
+      }
+    });
+    expect(fetchedData.amountAndCurrency).toEqual(
+      expect.objectContaining(expectedAmountAndCurrency)
+    );
+
+    fetchedData =  new DataInstance();
+    expect(fetchedData.amountAndCurrency).toEqual(
+      expect.objectContaining({
+        amount: undefined,
+        currency: undefined
+      })
+    );
+  });
+
+  it ('Should correctly determine isPayment', () => {
+    let fetchedData = new DataInstance({
+      state: {
+        options: {
+          money: true
+        }
+      }
+    });
+    expect(fetchedData.isPayment).toBeTruthy();
+
+    fetchedData = new DataInstance({
+      invoice: true
+    });
+    expect(fetchedData.isPayment).toBeTruthy();
+
+    fetchedData = new DataInstance({
+      transaction: true
+    });
+    expect(fetchedData.isPayment).toBeTruthy();
+
+    fetchedData = new DataInstance({
+      previewPurchase: true
+    });
+    expect(fetchedData.isPayment).toBeFalsy();
+
+    fetchedData = new DataInstance({});
+    expect(fetchedData.isPayment).toBeFalsy();
+  });
+
+  it ('Should correctly determine isPurchase', () => {
+    let fetchedData = new DataInstance({
+      previewPurchase: true
+    });
+    expect(fetchedData.isPurchase).toBeTruthy();
+    
+    fetchedData = new DataInstance({
+      state: {
+        options: {
+          money: true
+        }
+      }
+    });
+    expect(fetchedData.isPurchase).toBeFalsy();
+
+    fetchedData = new DataInstance({
+      invoice: true
+    });
+    expect(fetchedData.isPurchase).toBeFalsy();
+
+    fetchedData = new DataInstance({
+      transaction: true
+    });
+    expect(fetchedData.isPurchase).toBeFalsy();
+
+    fetchedData = new DataInstance({});
+    expect(fetchedData.isPurchase).toBeFalsy();
+  });
+
+  it ('Should get summaryItems', () => {
+    const expectedSummaryItems = {
+      discountsAmount: 1,
+      shippingAmount: 2,
+      subtotalAmount: 3,
+      taxAmount: 4
+    }
+
+    let fetchedData =  new DataInstance({
+      previewPurchase: {
+        ...expectedSummaryItems
+      }
+    });
+    expect(fetchedData.summaryItems).toEqual(
+      expect.objectContaining(expectedSummaryItems)
+    );
+
+    fetchedData =  new DataInstance({
+      invoice: {
+        ...expectedSummaryItems
+      }
+    });
+    expect(fetchedData.summaryItems).toEqual(
+      expect.objectContaining(expectedSummaryItems)
+    );
+  });
+
+  it ('Should get summaryLineItems', () => {
+    const expectedSummaryLineItems = [{
+      line: 'item'
+    }];
+
+    let fetchedData =  new DataInstance({
+      previewPurchase: {
+        lineItems: expectedSummaryLineItems
+      }
+    });
+    expect(fetchedData.summaryLineItems).toEqual(expectedSummaryLineItems);
+
+    fetchedData =  new DataInstance({
+      invoice: {
+        items: expectedSummaryLineItems
+      }
+    });
+    expect(fetchedData.summaryLineItems).toEqual(expectedSummaryLineItems);
+  });
+});
+