@rebilly/instruments 1.0.2-beta.9 → 3.0.0-beta.0

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

@@ -1,100 +1,70 @@
-import { MockStorefront } from 'tests/mocks/storefront-mock';
+import { StorefontTestingInstance } from 'tests/mocks/storefront-mock';
 import { ok, post } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchReadyToPay } from './ready-to-pay';
+import { fetchReadyToPay } from './ready-to-pay';
 import ReadyToPayModel from './models/ready-to-pay-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Ready to Pay', () => {
-  class TestReadyToPayInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
-      this.configs = configs;
-      this.options = options;
-      this.storefront = MockStorefront();
-    }
-
-    fetchReadyToPay(...args) {
-      return FetchReadyToPay.apply(this, args);
-    }
-  }
-  
-  it ('can fetch ready to pay', async () => {
-    const readyToPayPayload = [{
-      method: 'payment-card',
-      feature:null,
-      brands: ['Visa'],
-      filters:[]
-    }];
-    const configs = {
-      websiteId: 'test-website-id'
-    };
-    const options = {
-      intent: {
-        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
+        }
+      ]
     };
 
-    when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(ok(readyToPayPayload));
+    when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(
+      ok(readyToPayPayload)
+    );
 
-    const instance = new TestReadyToPayInstance({
-      configs,
-      options,
+    const instance = StorefontTestingInstance({
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'readyToPay');
 
-    const response = await instance.fetchReadyToPay();
-    
+    const riskMetadata = null;
+    const response = await fetchReadyToPay({ state: instance, riskMetadata });
+
     expect(instance.storefront.purchase.readyToPay).toBeCalledTimes(1);
     expect(instance.storefront.purchase.readyToPay).toBeCalledWith({
       data: {
-        items: options.intent.items,
-        websiteId: configs.websiteId,
+        items: options.items,
+        websiteId: options.websiteId,
         riskMetadata: {}
       }
     });
     expect(response).toBeInstanceOf(Array);
     expect(response[0]).toBeInstanceOf(ReadyToPayModel);
-    expect(response)
-      .toEqual([new ReadyToPayModel({
+    expect(response).toEqual([
+      new ReadyToPayModel({
         index: 0,
         ...readyToPayPayload[0]
-      })]);
+      })
+    ]);
   });
 
-  it ('should throw errors with no configs or options', () => {
-    const NoConfigOrOptionsError = new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
-    const noConfigOrOptionsInstance = new TestReadyToPayInstance({
-      configs: null,
-      options: null,
-    });
-    const noConfigInstance = new TestReadyToPayInstance({
-      configs: null,
-      options: {},
-    });
-    const noOptionsInstance = new TestReadyToPayInstance({
-      configs: {},
-      options: null,
-    });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.fetchReadyToPay();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+  it('should throw errors with no options', async () => {
+    const riskMetadata = null;
 
-    expect(async () => {
-      await noConfigInstance.fetchReadyToPay();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.fetchReadyToPay();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    const noConfigOrOptionsInstance = new StorefontTestingInstance({
+      options: null
+    });
+    await expectConfigurationError(
+      fetchReadyToPay({ riskMetadata, state: noConfigOrOptionsInstance })
+    );
   });
 });

package/src/storefront/storefront.spec.js

@@ -11,4 +11,4 @@ describe('Storefront application programming interface', () => {
     expect(storefront).toHaveProperty('purchase');
     expect(storefront.purchase).toHaveProperty('readyToPay');
   });
-});
+});

package/src/storefront/summary.js

@@ -1,37 +1,41 @@
 import SummaryModel from './models/summary-model';
+import { Endpoint } from './index';
 
-export async function FetchSummary ({
-  data = null
-} = {}) {
-  if (!this.storefront) {
-    throw new Error('Could not access rebilly-js-sdk instance');
-  }
-
-  if (!this.configs || !this.options) {
-    throw new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
-  }
-
-  try {
-    const websiteId = this.configs?.websiteId || null;
-    const items = this.options?.intent?.items || [];
+export async function fetchSummary({ data = null, state = null } = {}) {
+  return Endpoint({state}, async () => {
+    const websiteId = state.options?.websiteId || null;
 
     const payload = {
       data: {
-        websiteId,
-        items
+        websiteId
+      }
+    };
+
+    if (state.options?.items) {
+      payload.data.items = state.options.items;
+    }
+
+    if (state.data?.amountAndCurrency) {
+      payload.data = {
+        ...payload.data,
+        ...state.data.amountAndCurrency
       }
     }
+
     if (data?.billingAddress) {
       payload.data.billingAddress = data.billingAddress;
     }
-    if(data?.deliveryAddress) {
+    if (data?.deliveryAddress) {
       payload.data.deliveryAddress = data.deliveryAddress;
     }
 
-    const {fields: summaryFields} = await this.storefront.purchase.preview(payload);
+    const { fields: summaryFields } = await state.storefront.purchase.preview(
+      payload
+    );
+
+    // In case of preview purchase gets call again for updating the values
+    state.data.previewPurchase = summaryFields;
 
     return new SummaryModel(summaryFields);
-  } catch (error) {
-    throw error;
-  }
-};
+  });
+}

package/src/storefront/summary.spec.js

@@ -1,40 +1,21 @@
-import { MockStorefront } from 'tests/mocks/storefront-mock';
+import { StorefontTestingInstance } from 'tests/mocks/storefront-mock';
 import { ok, post } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchSummary } from './summary';
+import { fetchSummary } from './summary';
 import SummaryModel from '@/storefront/models/summary-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Summary', () => {
-  class TestSummaryInstance {
-    constructor({
-      configs = {},
-      options = {},
-      storefront = null,
-    } = {}) {
-      this.configs = configs;
-      this.options = options;
-      this.storefront = storefront === null ? MockStorefront() : storefront;
-    }
-
-    fetchSummary(...args) {
-      return FetchSummary.apply(this, args);
-    }
-  }
-  
-  it ('can fetch preview', async () => {
-    const configs = {
-      websiteId: 'test-website-id'
-    };
+  it('can fetch preview', async () => {
     const options = {
-      intent: {
-        items: [
-          {
-            planId: 'test-plan-id',
-            quantity: 1
-          }
-        ]
-      }
+      websiteId: 'test-website-id',
+      items: [
+        {
+          planId: 'test-plan-id',
+          quantity: 1
+        }
+      ]
     };
     const testSummary = {
       currency: 'USD',
@@ -42,142 +23,112 @@ describe('Storefront API Summary', () => {
         {
           description: 'test-plan-id-1',
           planId: 'test-plan-id-1',
-          quantity: 1,
+          quantity: 1
         }
       ]
     };
 
     when(post(`${storefrontURL}/preview-purchase`)).thenReturn(ok(testSummary));
 
-    const instance = new TestSummaryInstance({
-      configs,
-      options,
+    const instance = StorefontTestingInstance({
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'preview');
 
-    const response = await instance.fetchSummary();
-    
+    const response = await fetchSummary({ state: instance });
+
     expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
     expect(instance.storefront.purchase.preview).toBeCalledWith({
       data: {
-        items: options.intent.items,
-        websiteId: configs.websiteId,
+        items: options.items,
+        websiteId: options.websiteId
       }
     });
     expect(response).toBeInstanceOf(SummaryModel);
     expect(response).toEqual(new SummaryModel(testSummary));
-    
   });
 
-  it ('Adds billing address to preview payload', async () => {
-    const configs = {
-      websiteId: 'test-website-id'
-    };
+  it('Adds billing address to preview payload', async () => {
     const options = {
-      intent: {
-        items: [
-          {
-            planId: 'test-plan-id',
-            quantity: 1
-          }
-        ]
-      }
+      websiteId: 'test-website-id',
+      items: [
+        {
+          planId: 'test-plan-id',
+          quantity: 1
+        }
+      ]
     };
     const billingAddress = {
       firstName: 'Test',
       lastName: 'Customer'
     };
-    const instance = new TestSummaryInstance({
-      configs,
-      options,
+    const instance = StorefontTestingInstance({
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'preview');
 
-    await instance.fetchSummary({
+    await fetchSummary({
       data: {
-        billingAddress,
-      }
+        billingAddress
+      },
+      state: instance
     });
-    
+
     expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
     expect(instance.storefront.purchase.preview).toBeCalledWith({
       data: {
-        items: options.intent.items,
-        websiteId: configs.websiteId,
-        billingAddress,
+        items: options.items,
+        websiteId: options.websiteId,
+        billingAddress
       }
     });
   });
 
-  it ('Adds delivery address to preview payload', async () => {
-    const configs = {
-      websiteId: 'test-website-id'
-    };
+  it('Adds delivery address to preview payload', async () => {
     const options = {
-      intent: {
-        items: [
-          {
-            planId: 'test-plan-id',
-            quantity: 1
-          }
-        ]
-      }
+      websiteId: 'test-website-id',
+      items: [
+        {
+          planId: 'test-plan-id',
+          quantity: 1
+        }
+      ]
     };
     const deliveryAddress = {
       firstName: 'Test',
       lastName: 'Customer'
     };
-    const instance = new TestSummaryInstance({
-      configs,
-      options,
+    const instance = StorefontTestingInstance({
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'preview');
 
-    await instance.fetchSummary({
+    await fetchSummary({
       data: {
-        deliveryAddress,
-      }
+        deliveryAddress
+      },
+      state: instance
     });
-    
+
     expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
     expect(instance.storefront.purchase.preview).toBeCalledWith({
       data: {
-        items: options.intent.items,
-        websiteId: configs.websiteId,
-        deliveryAddress,
+        items: options.items,
+        websiteId: options.websiteId,
+        deliveryAddress
       }
     });
-    
   });
 
-  it ('should throw errors with no configs or options', () => {
-    const NoConfigOrOptionsError = new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
-    const noConfigOrOptionsInstance = new TestSummaryInstance({
-      configs: null,
-      options: null,
-    });
-    const noConfigInstance = new TestSummaryInstance({
-      configs: null,
-      options: {},
-    });
-    const noOptionsInstance = new TestSummaryInstance({
-      configs: {},
-      options: null,
+  it('should throw errors with no options', async () => {
+    const noConfigOrOptionsInstance = StorefontTestingInstance({
+      options: null
     });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.fetchSummary();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noConfigInstance.fetchSummary();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.fetchSummary();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    await expectConfigurationError(
+      fetchSummary({ state: noConfigOrOptionsInstance })
+    );
   });
 });

package/src/storefront/transactions.js

@@ -0,0 +1,11 @@
+import TransactionModel from './models/transaction-model';
+import { Endpoint } from './index';
+
+export async function fetchTransaction({ data = null, state = null }) {
+  return Endpoint({state}, async () => {
+    state.storefront.setSessionToken(state.options.customerJwt);
+    const {fields} = await state.storefront.transactions.get(data);
+
+    return new TransactionModel(fields);
+  });
+}