@rebilly/instruments 4.4.0 → 4.6.0

package/src/storefront/fetch-plans-from-addons-bumpOffer.js

@@ -3,26 +3,28 @@ import { Endpoint } from './index';
 import state from '../state';
 
 export async function fetchPlansFromAddonsBumpOffer() {
-  return Endpoint(async () => {
-    let ids = [];
+    return Endpoint(async () => {
+        let ids = [];
 
-    if (state.options?.addons) {
-      ids = ids.concat(state.options.addons
-        .map((item) => item.planId));
-    }
+        if (state.options?.addons) {
+            ids = ids.concat(state.options.addons.map((item) => item.planId));
+        }
 
-    if (state.options?.bumpOffer) {
-      ids = ids.concat(state.options.bumpOffer
-        .map((item) => item.planId));
-    }
+        if (state.options?.bumpOffer) {
+            ids = ids.concat(
+                state.options.bumpOffer.map((item) => item.planId),
+            );
+        }
 
-    if (ids.length > 0) {
-      const { items: planItems } = await state.storefront.plans.getAll({
-        filter: `id:${ids.join(',')}`
-      });
-      return planItems.map(({fields}) => new PlanModel(fields).toPayload());
-    }
+        if (ids.length > 0) {
+            const { items: planItems } = await state.storefront.plans.getAll({
+                filter: `id:${ids.join(',')}`,
+            });
+            return planItems.map(({ fields }) =>
+                new PlanModel(fields).toPayload(),
+            );
+        }
 
-    return [];
-  });
-}
+        return [];
+    });
+}

package/src/storefront/fetch-products-from-plans.js

@@ -3,56 +3,57 @@ import { Endpoint } from './index';
 import state from '../state';
 
 export async function fetchProductsFromPlans() {
-  return Endpoint(async () => {
-    let lineItems = state.data.summaryLineItems;
-    if(lineItems.length === 0)
-    {
-      lineItems = state.options?.items ?? [];
-    }
-
-    const filterByPlanId = {
-      filter: '',
-      expand: 'product'
-    };
-
-    if (lineItems.length) {
-      let ids = lineItems
-        .map((item) => item.planId);
-
-      if (state.options?.addons) {
-        ids = ids.concat(state.options.addons
-          .map((item) => item.planId));
-      }
-
-      if (state.options?.bumpOffer) {
-        ids = ids.concat(state.options.bumpOffer
-          .map((item) => item.planId));
-      }
-
-      filterByPlanId.filter = `id:${[...new Set(ids)].join(',')}`;
-    }
-
-    // Only fetch plans if we have specific plans to fetch
-    if (filterByPlanId.filter.length) {
-      try
-      {
-        const { items: planItems } = await state.storefront.plans.getAll(
-          filterByPlanId
-        );
-
-        const products = []
-        planItems
-          .map(({ fields }) => new ProductModel(fields._embedded.product))
-          .forEach(product => {
-            if (products.every(item => item.id !== product.id)) {
-              products.push(product)
+    return Endpoint(async () => {
+        let lineItems = state.data.summaryLineItems;
+        if (lineItems.length === 0) {
+            lineItems = state.options?.items ?? [];
+        }
+
+        const filterByPlanId = {
+            filter: '',
+            expand: 'product',
+        };
+
+        if (lineItems.length) {
+            let ids = lineItems.map((item) => item.planId);
+
+            if (state.options?.addons) {
+                ids = ids.concat(
+                    state.options.addons.map((item) => item.planId),
+                );
             }
-        });
-        return products;
-      } catch(e) {
-        // Ignore and return empty items
-      };
-    }
-    return [];
-  });
+
+            if (state.options?.bumpOffer) {
+                ids = ids.concat(
+                    state.options.bumpOffer.map((item) => item.planId),
+                );
+            }
+
+            filterByPlanId.filter = `id:${[...new Set(ids)].join(',')}`;
+        }
+
+        // Only fetch plans if we have specific plans to fetch
+        if (filterByPlanId.filter.length) {
+            try {
+                const { items: planItems } =
+                    await state.storefront.plans.getAll(filterByPlanId);
+
+                const products = [];
+                planItems
+                    .map(
+                        ({ fields }) =>
+                            new ProductModel(fields._embedded.product),
+                    )
+                    .forEach((product) => {
+                        if (products.every((item) => item.id !== product.id)) {
+                            products.push(product);
+                        }
+                    });
+                return products;
+            } catch (e) {
+                // Ignore and return empty items
+            }
+        }
+        return [];
+    });
 }

package/src/storefront/fetch-products-from-plans.spec.js

@@ -7,104 +7,107 @@ import ProductModel from './models/product-model';
 import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Plan', () => {
-  it('can fetch products from a single plan', async () => {
-    const testPlan = {
-      name: 'Test Plan',
-      id: 'test-plan-id-1',
-      _embedded: {
-        product: {
-          id: 'test-product-id',
-          requiresShipping: true
-        },
-      },
-    };
+    it('can fetch products from a single plan', async () => {
+        const testPlan = {
+            name: 'Test Plan',
+            id: 'test-plan-id-1',
+            _embedded: {
+                product: {
+                    id: 'test-product-id',
+                    requiresShipping: true,
+                },
+            },
+        };
 
-    when(get(`${storefrontURL}/plans`)).thenReturn(ok([testPlan]));
+        when(get(`${storefrontURL}/plans`)).thenReturn(ok([testPlan]));
 
-    const instance = new StorefontTestingInstance({
-      options: {
-        items: [
-          {
-            planId: 'test-plan-id-1'
-          }
-        ]
-      }
-    });
+        const instance = new StorefontTestingInstance({
+            options: {
+                items: [
+                    {
+                        planId: 'test-plan-id-1',
+                    },
+                ],
+            },
+        });
 
-    vi.spyOn(instance.storefront.plans, 'getAll');
+        vi.spyOn(instance.storefront.plans, 'getAll');
 
-    const products = await fetchProductsFromPlans({
-      state: instance
-    });
+        const products = await fetchProductsFromPlans({
+            state: instance,
+        });
 
-    expect(instance.storefront.plans.getAll).toBeCalledTimes(1);
-    expect(instance.storefront.plans.getAll).toBeCalledWith({
-      filter: 'id:test-plan-id-1',
-      expand: 'product'
+        expect(instance.storefront.plans.getAll).toBeCalledTimes(1);
+        expect(instance.storefront.plans.getAll).toBeCalledWith({
+            filter: 'id:test-plan-id-1',
+            expand: 'product',
+        });
+        expect(products).toEqual([
+            new ProductModel(testPlan._embedded.product),
+        ]);
     });
-    expect(products).toEqual([new ProductModel(testPlan._embedded.product)]);
-  });
 
-  it('can fetch multiple plans with multiple filters', async () => {
-    const testPlans = [
-      {
-        name: 'Test Plan 1',
-        id: 'test-plan-id-1',
-        _embedded: {
-          product: {
-            id: 'test-product-id-1',
-            requiresShipping: true
-          },
-        },
-      },
-      {
-        name: 'Test Plan 2',
-        id: 'test-plan-id-2',
-        _embedded: {
-          product: {
-            id: 'test-product-id-2',
-            requiresShipping: true
-          },
-        },
-      },
-    ];
-    when(get(`${storefrontURL}/plans`)).thenReturn(ok(testPlans));
+    it('can fetch multiple plans with multiple filters', async () => {
+        const testPlans = [
+            {
+                name: 'Test Plan 1',
+                id: 'test-plan-id-1',
+                _embedded: {
+                    product: {
+                        id: 'test-product-id-1',
+                        requiresShipping: true,
+                    },
+                },
+            },
+            {
+                name: 'Test Plan 2',
+                id: 'test-plan-id-2',
+                _embedded: {
+                    product: {
+                        id: 'test-product-id-2',
+                        requiresShipping: true,
+                    },
+                },
+            },
+        ];
+        when(get(`${storefrontURL}/plans`)).thenReturn(ok(testPlans));
 
-    const instance = new StorefontTestingInstance({
-      options: {
-        items: [
-          {
-            planId: 'test-plan-id-1'
-          },
-          {
-            planId: 'test-plan-id-2'
-          }
-        ]
-      }
-    });
+        const instance = new StorefontTestingInstance({
+            options: {
+                items: [
+                    {
+                        planId: 'test-plan-id-1',
+                    },
+                    {
+                        planId: 'test-plan-id-2',
+                    },
+                ],
+            },
+        });
 
-    vi.spyOn(instance.storefront.plans, 'getAll');
+        vi.spyOn(instance.storefront.plans, 'getAll');
 
-    const products = await fetchProductsFromPlans({
-      state: instance
-    });
+        const products = await fetchProductsFromPlans({
+            state: instance,
+        });
 
-    expect(instance.storefront.plans.getAll).toBeCalledWith(
-      expect.objectContaining({
-        filter: 'id:test-plan-id-1,test-plan-id-2',
-    }));
-    expect(products).toEqual([
-      new ProductModel(testPlans[0]._embedded.product),
-      new ProductModel(testPlans[1]._embedded.product),
-    ]);
-  });
+        expect(instance.storefront.plans.getAll).toBeCalledWith(
+            expect.objectContaining({
+                filter: 'id:test-plan-id-1,test-plan-id-2',
+            }),
+        );
+        expect(products).toEqual([
+            new ProductModel(testPlans[0]._embedded.product),
+            new ProductModel(testPlans[1]._embedded.product),
+        ]);
+    });
 
-  it('should throw errors with no options', async () => {
-    const noConfigOrOptionsInstance = new StorefontTestingInstance({
-      options: null
+    it('should throw errors with no options', async () => {
+        const noConfigOrOptionsInstance = new StorefontTestingInstance({
+            options: null,
+        });
+        await expectConfigurationError(
+            fetchProductsFromPlans({ state: noConfigOrOptionsInstance }),
+        );
     });
-    await expectConfigurationError(
-      fetchProductsFromPlans({ state: noConfigOrOptionsInstance })
-    );
-  });
 });

package/src/storefront/index.js

@@ -1,71 +1,78 @@
-import RebillyApi, {RebillyStorefrontAPI, RebillyExperimentalAPI} from 'rebilly-js-sdk';
+import RebillyApi, {
+    RebillyStorefrontAPI,
+    RebillyExperimentalAPI,
+} from 'rebilly-js-sdk';
 import { showError } from '../views/errors';
 import state from '../state';
 
 const TIMEOUT = 60000;
 
 export function validateStateForStorefront() {
-  if (!state.storefront) {
-    throw new Error('Could not access rebilly-js-sdk instance');
-  }
+    if (!state.storefront) {
+        throw new Error('Could not access rebilly-js-sdk instance');
+    }
 
-  if (!state.options) {
-    throw new Error(
-      'Could not use Rebilly Instruments mount options to fetch Rebilly data'
-    );
-  }
+    if (!state.options) {
+        throw new Error(
+            'Could not use Rebilly Instruments mount options to fetch Rebilly data',
+        );
+    }
 }
 
 export async function Endpoint(callback) {
-  try {
-    validateStateForStorefront({state});
-    return await callback();
-  } catch(error) {
-    showError(error);
-    throw error;
-  }
+    try {
+        validateStateForStorefront({ state });
+        return await callback();
+    } catch (error) {
+        showError(error);
+        throw error;
+    }
 }
 
 export class StorefrontInstance {
-  constructor({
-    publishableKey = null,
-    jwt = null,
-    organizationId = null,
-    mode = 'live',
-    timeout = TIMEOUT,
-    liveUrl = null,
-    sandboxUrl = null
-  } = {}) {
-    const urls = {
-      live: liveUrl || 'https://api.rebilly.com',
-      sandbox: sandboxUrl || 'https://api-sandbox.rebilly.com'
-    };
+    constructor({
+        publishableKey = null,
+        jwt = null,
+        organizationId = null,
+        mode = 'live',
+        timeout = TIMEOUT,
+        liveUrl = null,
+        sandboxUrl = null,
+    } = {}) {
+        const urls = {
+            live: liveUrl || 'https://api.rebilly.com',
+            sandbox: sandboxUrl || 'https://api-sandbox.rebilly.com',
+        };
 
-    const config = {
-      organizationId,
-      sandbox: mode === 'sandbox',
-      timeout: Number.isNaN(parseInt(timeout, 10))
-        ? TIMEOUT
-        : parseInt(timeout, 10),
-      urls
-    };
+        const config = {
+            organizationId,
+            sandbox: mode === 'sandbox',
+            timeout: Number.isNaN(parseInt(timeout, 10))
+                ? TIMEOUT
+                : parseInt(timeout, 10),
+            urls,
+        };
 
-    const api = RebillyStorefrontAPI(config);
-    // TODO: Check why Rollup is making the default as an named export
-    const rebilly = typeof RebillyApi.default === 'function' ? RebillyApi.default(config) : RebillyApi(config);
+        const api = RebillyStorefrontAPI(config);
+        // TODO: Check why Rollup is making the default as an named export
+        const rebilly =
+            typeof RebillyApi.default === 'function'
+                ? RebillyApi.default(config)
+                : RebillyApi(config);
 
-    const experimental = RebillyExperimentalAPI(config);
+        const experimental = RebillyExperimentalAPI(config);
 
-    api.setSessionToken(publishableKey || jwt);
-    rebilly.setSessionToken(publishableKey || jwt);
-    experimental.setSessionToken(publishableKey || jwt);
+        api.setSessionToken(publishableKey || jwt);
+        rebilly.setSessionToken(publishableKey || jwt);
+        experimental.setSessionToken(publishableKey || jwt);
 
-    this.api = api;
-    this.api.rebilly = rebilly;
-    this.api.rebilly.experimental = experimental;
+        this.api = api;
+        this.api.rebilly = rebilly;
+        this.api.rebilly.experimental = experimental;
 
-    return this.api;
-  }
+        // eslint-disable-next-line no-constructor-return
+        return this.api;
+    }
 }
 
 export default (config = {}) => new StorefrontInstance(config);

package/src/storefront/invoices.js

@@ -4,20 +4,20 @@ import { Endpoint } from './index';
 import state from '../state';
 
 export async function fetchInvoiceAndProducts({ data = null }) {
-  return Endpoint(async () => {
-    state.storefront.setSessionToken(state.options.jwt);
-    const {fields} = await state.storefront.invoices.get({
-      ...data,
-      expand: 'items.*.product'
-    });
+    return Endpoint(async () => {
+        state.storefront.setSessionToken(state.options.jwt);
+        const { fields } = await state.storefront.invoices.get({
+            ...data,
+            expand: 'items.*.product',
+        });
 
-    const products = fields.items
-      .filter(item => item._embedded)
-      .map(items => new ProductModel(items._embedded.product));
+        const products = fields.items
+            .filter((item) => item._embedded)
+            .map((items) => new ProductModel(items._embedded.product));
 
-    return {
-      products,
-      invoice: new InvoiceModel(fields),
-    };
-  });
-}
+        return {
+            products,
+            invoice: new InvoiceModel(fields),
+        };
+    });
+}

package/src/storefront/invoices.spec.js

@@ -7,82 +7,86 @@ import ProductModel from './models/product-model';
 import InvoiceModel from './models/invoice-model';
 
 describe('Storefront Invoices', () => {
-  it('can fetch an invoice and its embedded products', async () => {
-    const id = '1234';
-    const testInvoice = {
-      id: 'test-invoice-id-1',
-      items: [
-        {
-          _embedded: {
-            product: {
-              id: 'test-product-id'
-            }
-          }
-        }
-      ]
-    };
+    it('can fetch an invoice and its embedded products', async () => {
+        const id = '1234';
+        const testInvoice = {
+            id: 'test-invoice-id-1',
+            items: [
+                {
+                    _embedded: {
+                        product: {
+                            id: 'test-product-id',
+                        },
+                    },
+                },
+            ],
+        };
 
-    when(get(`${storefrontURL}/invoices/${id}`)).thenReturn(ok(testInvoice));
+        when(get(`${storefrontURL}/invoices/${id}`)).thenReturn(
+            ok(testInvoice),
+        );
 
-    const instance = new StorefontTestingInstance({
-      data: {
-        invoice: {
-          id
-        }
-      }
-    });
+        const instance = new StorefontTestingInstance({
+            data: {
+                invoice: {
+                    id,
+                },
+            },
+        });
 
-    vi.spyOn(instance.storefront.invoices, 'get');
+        vi.spyOn(instance.storefront.invoices, 'get');
 
-    const { invoice, products } = await fetchInvoiceAndProducts({
-      data: { id },
-      state: instance
-    });
+        const { invoice, products } = await fetchInvoiceAndProducts({
+            data: { id },
+            state: instance,
+        });
 
-    expect(instance.storefront.invoices.get).toBeCalledTimes(1);
-    expect(instance.storefront.invoices.get).toBeCalledWith({
-      id,
-      expand: 'items.*.product'
-    });
-    expect(invoice).toBeInstanceOf(InvoiceModel);
-    expect(products).toBeInstanceOf(Array);
-    expect(products[0]).toBeInstanceOf(ProductModel);
-    expect(products[0]).toMatchInlineSnapshot(`
+        expect(instance.storefront.invoices.get).toBeCalledTimes(1);
+        expect(instance.storefront.invoices.get).toBeCalledWith({
+            id,
+            expand: 'items.*.product',
+        });
+        expect(invoice).toBeInstanceOf(InvoiceModel);
+        expect(products).toBeInstanceOf(Array);
+        expect(products[0]).toBeInstanceOf(ProductModel);
+        expect(products[0]).toMatchInlineSnapshot(`
       ProductModel {
         "id": "test-product-id",
       }
     `);
-  });
+    });
 
-  it('can fetch an invoice when it does not have any products', async () => {
-    const id = '1234';
-    const testInvoice = {
-      id: 'test-invoice-id-1',
-      items: [
-        {
-          id: 'test',
-          price: 0.99,
-        }
-      ]
-    };
+    it('can fetch an invoice when it does not have any products', async () => {
+        const id = '1234';
+        const testInvoice = {
+            id: 'test-invoice-id-1',
+            items: [
+                {
+                    id: 'test',
+                    price: 0.99,
+                },
+            ],
+        };
 
-    when(get(`${storefrontURL}/invoices/${id}`)).thenReturn(ok(testInvoice));
+        when(get(`${storefrontURL}/invoices/${id}`)).thenReturn(
+            ok(testInvoice),
+        );
 
-    const instance = new StorefontTestingInstance({
-      data: {
-        invoice: {
-          id
-        }
-      }
-    });
-  
-    const { invoice, products } = await fetchInvoiceAndProducts({
-      data: { id },
-      state: instance
-    });
+        const instance = new StorefontTestingInstance({
+            data: {
+                invoice: {
+                    id,
+                },
+            },
+        });
 
-    expect(invoice).toBeInstanceOf(InvoiceModel);
-    expect(products).toBeInstanceOf(Array);
-    expect(products.length).toBe(0);
-  });
+        const { invoice, products } = await fetchInvoiceAndProducts({
+            data: { id },
+            state: instance,
+        });
+
+        expect(invoice).toBeInstanceOf(InvoiceModel);
+        expect(products).toBeInstanceOf(Array);
+        expect(products.length).toBe(0);
+    });
 });