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

package/src/storefront/plans.js

@@ -1,30 +1,23 @@
 import PlanModel from './models/plan-model';
+import { Endpoint } from './index';
 
-export async function FetchPlans ({
-  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 { lineItems } = data || {};
+export async function fetchPlans({ state = {}, data = {} }) {
+  return Endpoint({state}, async () => {
+    const lineItems = data.lineItems || state.data.summaryLineItems;
 
     const filterByPlanId = {
-      filter: '',
-    }
+      filter: ''
+    };
 
-    if (lineItems) {
-      filterByPlanId.filter = `id:${lineItems.map(item => item.planId).join(',')}`;
+    if (lineItems.length) {
+      filterByPlanId.filter = `id:${lineItems
+        .map((item) => item.planId)
+        .join(',')}`;
     }
 
-    const {items: planItems} = await this.storefront.plans.getAll(filterByPlanId);
-    return planItems.map(({fields}) => new PlanModel(fields));
-  } catch (error) {
-    throw error;
-  }
-};
+    const { items: planItems } = await state.storefront.plans.getAll(
+      filterByPlanId
+    );
+    return planItems.map(({ fields }) => new PlanModel(fields));
+  });
+}

package/src/storefront/plans.spec.js

@@ -1,36 +1,22 @@
-import { MockStorefront } from 'tests/mocks/storefront-mock';
+import { StorefontTestingInstance } from 'tests/mocks/storefront-mock';
 import { ok, get } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchPlans } from './plans';
+import { fetchPlans } from './plans';
 import PlanModel from './models/plan-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Plan', () => {
-  class TestPlansInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
-      this.configs = configs;
-      this.options = options;
-      this.storefront = MockStorefront();
-    }
-
-    fetchPlans(...args) {
-      return FetchPlans.apply(this, args);
-    }
-  }
-  
-  it ('can fetch plans', async () => {
-    const testPlan = {name: 'Test Plan', id: 'test-plan-id-1'};
+  it('can fetch plans', async () => {
+    const testPlan = { name: 'Test Plan', id: 'test-plan-id-1' };
 
     when(get(`${storefrontURL}/plans`)).thenReturn(ok([testPlan]));
 
-    const instance = new TestPlansInstance();
+    const instance = new StorefontTestingInstance();
 
     jest.spyOn(instance.storefront.plans, 'getAll');
 
-    const response = await instance.fetchPlans({});
+    const response = await fetchPlans({ state: instance });
 
     expect(instance.storefront.plans.getAll).toBeCalledTimes(1);
     expect(instance.storefront.plans.getAll).toBeCalledWith({
@@ -41,18 +27,22 @@ describe('Storefront API Plan', () => {
     expect(response).toEqual([new PlanModel(testPlan)]);
   });
 
-  it ('can fetch plans with filter', async () => {
-    const instance = new TestPlansInstance();
+  it('can fetch plans with filter', async () => {
+    const instance = new StorefontTestingInstance();
 
     jest.spyOn(instance.storefront.plans, 'getAll');
 
-    await instance.fetchPlans({
+    await fetchPlans({
+      state: instance,
       data: {
-        lineItems: [{
-          planId: 'test-plan-id-1'
-        }, {
-          planId: 'test-plan-id-2'
-        }]
+        lineItems: [
+          {
+            planId: 'test-plan-id-1'
+          },
+          {
+            planId: 'test-plan-id-2'
+          }
+        ]
       }
     });
 
@@ -61,31 +51,12 @@ describe('Storefront API Plan', () => {
     });
   });
 
-  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 TestPlansInstance({
-      configs: null,
-      options: null,
-    });
-    const noConfigInstance = new TestPlansInstance({
-      configs: null,
-      options: {},
-    });
-    const noOptionsInstance = new TestPlansInstance({
-      configs: {},
-      options: null,
+  it('should throw errors with no options', async () => {
+    const noConfigOrOptionsInstance = new StorefontTestingInstance({
+      options: null
     });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.fetchPlans();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noConfigInstance.fetchPlans();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.fetchPlans();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    await expectConfigurationError(
+      fetchPlans({ state: noConfigOrOptionsInstance })
+    );
   });
 });

package/src/storefront/products.js

@@ -1,30 +1,26 @@
 import ProductModel from './models/product-model';
+import { Endpoint } from './index';
 
-export async function FetchProducts ({
-  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 plansData = data || [];
+export async function fetchProducts({ state }) {
+  return Endpoint({state}, async () => {
+    if (state.data.plans === null) {
+      return null;
+    }
 
+    const plansData = state.data.plans || [];
     const filterByProductId = {
-      filter: '',
-    }
+      filter: ''
+    };
 
     if (plansData.length) {
-      filterByProductId.filter = `id:${plansData.map(item => item.productId).join(',')}`;
+      filterByProductId.filter = `id:${plansData
+        .map((item) => item.productId)
+        .join(',')}`;
     }
 
-    const {items: productItems} = await this.storefront.products.getAll(filterByProductId);
-    return productItems.map(({fields}) => new ProductModel(fields));
-  } catch (error) {
-    throw error;
-  }
-};
+    const { items: productItems } = await state.storefront.products.getAll(
+      filterByProductId
+    );
+    return productItems.map(({ fields }) => new ProductModel(fields));
+  });
+}

package/src/storefront/products.spec.js

@@ -1,36 +1,22 @@
-import { MockStorefront } from 'tests/mocks/storefront-mock';
+import { StorefontTestingInstance } from 'tests/mocks/storefront-mock';
 import { ok, get } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchProducts } from './products';
+import { fetchProducts } from './products';
 import ProductModel from './models/product-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Plan', () => {
-  class TestProductsInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
-      this.configs = configs;
-      this.options = options;
-      this.storefront = MockStorefront();
-    }
-
-    FetchProducts(...args) {
-      return FetchProducts.apply(this, args);
-    }
-  }
-  
-  it ('can fetch products', async () => {
-    const testProduct = {name: 'Test Product', id: 'test-product-id-1'};
+  it('can fetch products', async () => {
+    const testProduct = { name: 'Test Product', id: 'test-product-id-1' };
 
     when(get(`${storefrontURL}/products`)).thenReturn(ok([testProduct]));
 
-    const instance = new TestProductsInstance();
+    const instance = new StorefontTestingInstance();
 
     jest.spyOn(instance.storefront.products, 'getAll');
 
-    const response = await instance.FetchProducts({});
+    const response = await fetchProducts({ state: instance });
 
     expect(instance.storefront.products.getAll).toBeCalledTimes(1);
     expect(instance.storefront.products.getAll).toBeCalledWith({
@@ -41,52 +27,35 @@ describe('Storefront API Plan', () => {
     expect(response).toEqual([new ProductModel(testProduct)]);
   });
 
-  it ('can fetch products with filter', async () => {
-    const instance = new TestProductsInstance();
-
-    jest.spyOn(instance.storefront.products, 'getAll');
-
-    await instance.FetchProducts({
-      data: [
+  it('can fetch products with filter', async () => {
+    const instance = new StorefontTestingInstance({
+      data: {
+        plans: [
           {
             productId: 'test-product-1'
           },
           {
             productId: 'test-product-2'
           }
-      ],
+        ]
+      }
     });
 
+    jest.spyOn(instance.storefront.products, 'getAll');
+
+    await fetchProducts({ state: instance });
+
     expect(instance.storefront.products.getAll).toBeCalledWith({
       filter: 'id:test-product-1,test-product-2'
     });
   });
 
-  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 TestProductsInstance({
-      configs: null,
-      options: null,
-    });
-    const noConfigInstance = new TestProductsInstance({
-      configs: null,
-      options: {},
-    });
-    const noOptionsInstance = new TestProductsInstance({
-      configs: {},
-      options: null,
+  it('should throw errors with no options', async () => {
+    const noConfigOrOptionsInstance = new StorefontTestingInstance({
+      options: null
     });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.FetchProducts();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noConfigInstance.FetchProducts();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.FetchProducts();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    await expectConfigurationError(
+      fetchProducts({ state: noConfigOrOptionsInstance })
+    );
   });
 });

package/src/storefront/purchase.js

@@ -1,19 +1,19 @@
-export async function PostPurchase (data) {
-  if (!this.storefront) {
-    throw new Error('Could not access rebilly-js-sdk instance');
-  }
+import { Endpoint } from './index';
 
-  if (!this.configs || !this.options) {
-    throw new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
-  }
+export async function postPurchase({ data, state }) {
+  return Endpoint({state}, async () => {
+    if (data._raw) {
+      delete data._raw;
+    }
+    return state.storefront.purchase.purchase({ data });
+  });
+}
 
-  try {
+export async function postPayment({ data, state }) {
+  return Endpoint({state}, async () => {
     if (data._raw) {
       delete data._raw;
     }
-    const resp = await this.storefront.purchase.purchase({data});
-    return resp;
-  } catch (error) {
-    throw error;
-  }
-};
+    return state.storefront.purchase.payment({ data });
+  });
+}

package/src/storefront/purchase.spec.js

@@ -1,40 +1,26 @@
-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 { PostPurchase } from './purchase';
 
 describe('Storefront API Purchase', () => {
-  class TestPurchaseInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
-      this.configs = configs;
-      this.options = options;
-      this.storefront = MockStorefront();
-    }
-
-    postPurchase(...args) {
-      return PostPurchase.apply(this, args);
-    }
-  }
-
-  it ('can make purchase', async () => {
-    const instance = new TestPurchaseInstance();
+  it('can make purchase', async () => {
+    const instance = StorefontTestingInstance();
     const payload = {
       websiteId: 'test-website-id',
-      items: [{
-        planId: 'test-plan-id-1',
-        quantity: 1
-      }],
+      items: [
+        {
+          planId: 'test-plan-id-1',
+          quantity: 1
+        }
+      ],
       billingAddress: {
         firstName: 'Test',
         lastName: 'Customer'
       },
       paymentInstruction: {
-        token: 'test-token',
-      },
+        token: 'test-token'
+      }
     };
     const fields = {
       orderId: 'test-order-id',
@@ -44,17 +30,19 @@ describe('Storefront API Purchase', () => {
       transaction: {
         id: 'test-transaction-id'
       }
-    }
+    };
 
     when(post(`${storefrontURL}/purchase`)).thenReturn(ok(fields));
 
     jest.spyOn(instance.storefront.purchase, 'purchase');
 
-    const requestResponse = await instance.storefront.purchase.purchase(payload);
+    const requestResponse = await instance.storefront.purchase.purchase(
+      payload
+    );
 
     expect(instance.storefront.purchase.purchase).toBeCalledTimes(1);
     expect(instance.storefront.purchase.purchase).toBeCalledWith(payload);
-    
+
     expect(requestResponse.config).toBeInstanceOf(Object);
     expect(requestResponse.fields).toBeInstanceOf(Object);
     expect(requestResponse.response).toBeInstanceOf(Object);
@@ -62,4 +50,4 @@ describe('Storefront API Purchase', () => {
     expect(requestResponse.fields).toEqual(fields);
     expect(requestResponse.fields).toMatchObject(fields);
   });
-});
+});

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

@@ -1,36 +1,39 @@
 import { collectData } from '@rebilly/risk-data-collector';
 import ReadyToPayModel from './models/ready-to-pay-model';
+import { Endpoint } from './index';
 
-export async function FetchReadyToPay (riskMetadata = 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 {
+export async function fetchReadyToPay({ state, riskMetadata = null }) {
+  return Endpoint({state}, async () => {
     if (!riskMetadata) {
-      const {riskMetadata: data} = await collectData();
+      const { riskMetadata: data } = await collectData();
       riskMetadata = data;
     }
-    const websiteId = this.configs?.websiteId || null;
-    const items = this.options?.intent?.items || [];
+    const websiteId = state.options?.websiteId || null;
 
     const data = {
-      items,
       websiteId,
       riskMetadata
     };
 
-    const {fields: readyToPayFields} = await this.storefront.purchase.readyToPay({data});
+    if (state.options?.items) {
+      data.items = state.options.items;
+    }
+
+    if (state.data?.amountAndCurrency) {
+      const money = state.data.amountAndCurrency;
+      data.amount = money.amount;
+      data.currency = money.currency;
+    }
+
+    const { fields: readyToPayFields } =
+      await state.storefront.purchase.readyToPay({ data });
 
-    return Object.values(readyToPayFields).map((fields, index) => new ReadyToPayModel({
-        index,
-        ...fields,
-      }));
-  } catch (error) {
-    throw error;
-  }
-};
+    return Object.values(readyToPayFields).map(
+      (fields, index) =>
+        new ReadyToPayModel({
+          index,
+          ...fields
+        })
+    );
+  });
+}

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');
   });
-});
+});