@rebilly/instruments 4.8.1 → 4.8.2

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

@@ -1,30 +0,0 @@
-import PlanModel from './models/plan-model';
-import { Endpoint } from './index';
-import state from '../state';
-
-export async function fetchPlansFromAddonsBumpOffer() {
-    return Endpoint(async () => {
-        let ids = [];
-
-        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 (ids.length > 0) {
-            const { items: planItems } = await state.storefront.plans.getAll({
-                filter: `id:${ids.join(',')}`,
-            });
-            return planItems.map(({ fields }) =>
-                new PlanModel(fields).toPayload(),
-            );
-        }
-
-        return [];
-    });
-}

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

@@ -1,59 +0,0 @@
-import ProductModel from './models/product-model';
-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 products;
-            } catch (e) {
-                // Ignore and return empty items
-            }
-        }
-        return [];
-    });
-}

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

@@ -1,113 +0,0 @@
-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 { fetchProductsFromPlans } from './fetch-products-from-plans';
-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,
-                },
-            },
-        };
-
-        when(get(`${storefrontURL}/plans`)).thenReturn(ok([testPlan]));
-
-        const instance = new StorefontTestingInstance({
-            options: {
-                items: [
-                    {
-                        planId: 'test-plan-id-1',
-                    },
-                ],
-            },
-        });
-
-        vi.spyOn(instance.storefront.plans, 'getAll');
-
-        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(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));
-
-        const instance = new StorefontTestingInstance({
-            options: {
-                items: [
-                    {
-                        planId: 'test-plan-id-1',
-                    },
-                    {
-                        planId: 'test-plan-id-2',
-                    },
-                ],
-            },
-        });
-
-        vi.spyOn(instance.storefront.plans, 'getAll');
-
-        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),
-        ]);
-    });
-
-    it('should throw errors with no options', async () => {
-        const noConfigOrOptionsInstance = new StorefontTestingInstance({
-            options: null,
-        });
-        await expectConfigurationError(
-            fetchProductsFromPlans({ state: noConfigOrOptionsInstance }),
-        );
-    });
-});

package/src/storefront/index.js

@@ -1,78 +0,0 @@
-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.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;
-    }
-}
-
-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',
-        };
-
-        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 experimental = RebillyExperimentalAPI(config);
-
-        api.setSessionToken(publishableKey || jwt);
-        rebilly.setSessionToken(publishableKey || jwt);
-        experimental.setSessionToken(publishableKey || jwt);
-
-        this.api = api;
-        this.api.rebilly = rebilly;
-        this.api.rebilly.experimental = experimental;
-
-        // eslint-disable-next-line no-constructor-return
-        return this.api;
-    }
-}
-
-export default (config = {}) => new StorefrontInstance(config);

package/src/storefront/invoices.js

@@ -1,23 +0,0 @@
-import InvoiceModel from './models/invoice-model';
-import ProductModel from './models/product-model';
-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',
-        });
-
-        const products = fields.items
-            .filter((item) => item._embedded)
-            .map((items) => new ProductModel(items._embedded.product));
-
-        return {
-            products,
-            invoice: new InvoiceModel(fields),
-        };
-    });
-}

package/src/storefront/invoices.spec.js

@@ -1,92 +0,0 @@
-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 { fetchInvoiceAndProducts } from './invoices';
-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',
-                        },
-                    },
-                },
-            ],
-        };
-
-        when(get(`${storefrontURL}/invoices/${id}`)).thenReturn(
-            ok(testInvoice),
-        );
-
-        const instance = new StorefontTestingInstance({
-            data: {
-                invoice: {
-                    id,
-                },
-            },
-        });
-
-        vi.spyOn(instance.storefront.invoices, 'get');
-
-        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(`
-      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,
-                },
-            ],
-        };
-
-        when(get(`${storefrontURL}/invoices/${id}`)).thenReturn(
-            ok(testInvoice),
-        );
-
-        const instance = new StorefontTestingInstance({
-            data: {
-                invoice: {
-                    id,
-                },
-            },
-        });
-
-        const { invoice, products } = await fetchInvoiceAndProducts({
-            data: { id },
-            state: instance,
-        });
-
-        expect(invoice).toBeInstanceOf(InvoiceModel);
-        expect(products).toBeInstanceOf(Array);
-        expect(products.length).toBe(0);
-    });
-});

package/src/storefront/models/account-model.js

@@ -1,36 +0,0 @@
-import BaseModel from './base-model';
-
-export class AddressModel {
-    constructor({
-        firstName = null,
-        lastName = null,
-        organization = null,
-        address = null,
-        address2 = null,
-        city = null,
-        region = null,
-        country = null,
-        postalCode = null,
-        emails = [],
-        phoneNumbers = [],
-    } = {}) {
-        this.firstName = firstName;
-        this.lastName = lastName;
-        this.organization = organization;
-        this.address = address;
-        this.address2 = address2;
-        this.city = city;
-        this.region = region;
-        this.country = country;
-        this.postalCode = postalCode;
-        this.email = emails.find((v) => v.primary)?.value || null;
-        this.phoneNumber = phoneNumbers.find((v) => v.primary)?.value || null;
-    }
-}
-
-export default class AccountModel extends BaseModel {
-    constructor({ primaryAddress = {}, ...fields } = {}) {
-        super(fields);
-        this.address = new AddressModel({ ...primaryAddress });
-    }
-}

package/src/storefront/models/base-model.js

@@ -1,7 +0,0 @@
-export default class BaseModel {
-    constructor({ ...fields } = {}) {
-        Object.entries(fields).forEach(([key, value]) => {
-            this[key] = value;
-        });
-    }
-}

package/src/storefront/models/deposit-request-model.js

@@ -1,24 +0,0 @@
-import merge from 'lodash.merge';
-import BaseModel from './base-model';
-
-export default class DepositRequestModel extends BaseModel {
-    constructor(fields) {
-        super(fields);
-        this.amount = Array.isArray(fields.amounts)
-            ? fields.amounts[0]
-            : fields.amount;
-        this.buttons = fields.buttons ?? [...fields.amounts];
-        this.editable =
-            typeof fields.editable === 'boolean'
-                ? fields.editable
-                : Boolean(fields.customAmount);
-        this.customAmount = merge(
-            {
-                minimum: 1,
-                maximum: 1000000000000,
-                multipleOf: 1,
-            },
-            fields.customAmount || {},
-        );
-    }
-}

package/src/storefront/models/invoice-model.js

@@ -1,20 +0,0 @@
-import BaseModel from './base-model';
-
-export default class InvoiceModel extends BaseModel {
-    static Status = {
-        draft: 'draft',
-        unpaid: 'unpaid',
-        paid: 'paid',
-        partiallyPaid: 'partially-paid',
-        pastDue: 'past-due',
-        abandoned: 'abandoned',
-        voided: 'voided',
-        partiallyRefunded: 'partially-refunded',
-        refunded: 'refunded',
-        disputed: 'disputed',
-    };
-
-    get isPaid() {
-        return this.status === InvoiceModel.Status.paid;
-    }
-}

package/src/storefront/models/payment-metadata.js

@@ -1,7 +0,0 @@
-import BaseModel from './base-model';
-
-export default class PaymentMetadataModel extends BaseModel {
-    get logo() {
-        return this.landscapeLogo || this.portraitLogo;
-    }
-}

package/src/storefront/models/plan-model.js

@@ -1,94 +0,0 @@
-import BaseModel from './base-model';
-
-export class PlanPricingBracketModel {
-    constructor({ maxQuantity = null, price = null } = {}) {
-        this.maxQuantity = maxQuantity || Number.MAX_SAFE_INTEGER;
-        this.price = !Number.isNaN(parseFloat(price))
-            ? parseFloat(price)
-            : null;
-    }
-}
-
-export class PlanPricingModel {
-    static SimpleFormulas = {
-        fixedFee: 'fixed-fee',
-        flatRate: 'flat-rate',
-    };
-
-    static BracketFormulas = {
-        stairstep: 'stairstep',
-        tiered: 'tiered',
-        volume: 'volume',
-    };
-
-    static Formulas = {
-        ...PlanPricingModel.SimpleFormulas,
-        ...PlanPricingModel.BracketFormulas,
-    };
-
-    constructor({
-        formula = PlanPricingModel.Formulas.fixedFee,
-        price = 0,
-        maxQuantity = null,
-        brackets = [],
-    } = {}) {
-        this.formula = formula;
-
-        switch (this.formula) {
-            case PlanPricingModel.Formulas.stairstep:
-            case PlanPricingModel.Formulas.tiered:
-            case PlanPricingModel.Formulas.volume:
-                this.brackets = brackets.map(
-                    (bracket) => new PlanPricingBracketModel(bracket),
-                );
-                break;
-            case PlanPricingModel.Formulas.flatRate:
-                this.price = !Number.isNaN(parseFloat(price))
-                    ? parseFloat(price)
-                    : null;
-                this.maxQuantity = maxQuantity;
-                break;
-            case PlanPricingModel.Formulas.fixedFee:
-            default:
-                this.price = !Number.isNaN(parseFloat(price))
-                    ? parseFloat(price)
-                    : null;
-                break;
-        }
-    }
-
-    get isSimple() {
-        return Object.values(PlanPricingModel.SimpleFormulas).includes(
-            this.formula,
-        );
-    }
-
-    get isBracket() {
-        return Object.values(PlanPricingModel.BracketFormulas).includes(
-            this.formula,
-        );
-    }
-
-    toPayload() {
-        return {
-            ...this,
-            isSimple: this.isSimple,
-            isBracket: this.isBracket,
-        };
-    }
-}
-
-export default class PlanModel extends BaseModel {
-    constructor(fields = {}) {
-        super(fields);
-
-        this.pricing = new PlanPricingModel(fields.pricing || {});
-    }
-
-    toPayload() {
-        return {
-            ...this,
-            pricing: this.pricing.toPayload(),
-        };
-    }
-}

package/src/storefront/models/product-model.js

@@ -1,3 +0,0 @@
-import BaseModel from './base-model';
-
-export default class ProductModel extends BaseModel {}

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

@@ -1,76 +0,0 @@
-import PaymentMetadataModel from './payment-metadata';
-
-export class ReadyToPayFeatureModel {
-    static FeatureName = {
-        paypalBillingAgreement: 'PayPal billing agreement',
-        googlePay: 'Google Pay',
-        applePay: 'Apple Pay',
-    };
-
-    constructor({
-        name = '',
-        expirationTime = '',
-
-        // Apple Pay fields
-        displayName = '',
-        country = '',
-
-        // Google Pay fields
-        merchantName = '',
-        merchantOrigin = '',
-
-        // Paypal fields
-        paypalMerchantId = '',
-        billingAgreementToken = '',
-        paypalClientId = '',
-
-        // Plaid fields
-        linkToken = '',
-    } = {}) {
-        this.name = name;
-        this.expirationTime = expirationTime;
-
-        this.displayName = displayName;
-        this.country = country;
-
-        this.merchantName = merchantName;
-        this.merchantOrigin = merchantOrigin;
-
-        this.paypalMerchantId = paypalMerchantId;
-        this.billingAgreementToken = billingAgreementToken;
-        this.paypalClientId = paypalClientId;
-
-        this.linkToken = linkToken;
-    }
-}
-
-export default class ReadyToPayModel {
-    constructor({
-        index = null,
-        method = '',
-        feature = null,
-        brands = [],
-        filters = [],
-        metadata = null,
-    } = {}) {
-        this.index = index;
-        this.method = method;
-        this.feature = feature ? new ReadyToPayFeatureModel(feature) : null;
-        this.brands = brands;
-        this.filters = filters;
-        this.metadata = metadata ? new PaymentMetadataModel(metadata) : null;
-    }
-
-    get optionsPaymentInstrumentsKey() {
-        switch (this.feature?.name) {
-            case ReadyToPayFeatureModel.FeatureName.paypalBillingAgreement:
-                return 'paypal';
-            case ReadyToPayFeatureModel.FeatureName.googlePay:
-                return 'googlePay';
-            case ReadyToPayFeatureModel.FeatureName.applePay:
-                return 'applePay';
-            default:
-                return undefined;
-        }
-    }
-}