@rebilly/instruments 4.8.1 → 4.8.3

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

@@ -1,56 +0,0 @@
-import BaseModel from './base-model';
-
-export class SummaryLineItemModel extends BaseModel {
-    constructor({
-        unitPrice = 0.0,
-        quantity = 0,
-        price = 0.0,
-        ...fields
-    } = {}) {
-        super(fields);
-        this.unitPrice = unitPrice;
-        this.quantity = quantity;
-        this.price = price;
-    }
-}
-
-export class SummaryTaxModel extends BaseModel {}
-
-export class SummaryDiscountModel extends BaseModel {
-    constructor({ amount = 0, ...fields }) {
-        super(fields);
-        this.amount = amount;
-    }
-}
-
-export default class SummaryModel {
-    constructor({
-        currency = '',
-        lineItems = [],
-        taxes = [],
-        discounts = [],
-        subtotalAmount = 0.0,
-        taxAmount = 0.0,
-        shippingAmount = 0.0,
-        discountsAmount = 0.0,
-        total = 0.0,
-    } = {}) {
-        function map(array) {
-            const list = Array.isArray(array) ? array : [];
-            return {
-                // eslint-disable-next-line new-cap
-                to: (instance) => list.map((item) => new instance(item)),
-            };
-        }
-
-        this.currency = currency;
-        this.lineItems = map(lineItems).to(SummaryLineItemModel);
-        this.taxes = map(taxes).to(SummaryTaxModel);
-        this.discounts = map(discounts).to(SummaryDiscountModel);
-        this.subtotalAmount = subtotalAmount;
-        this.taxAmount = taxAmount;
-        this.shippingAmount = shippingAmount;
-        this.discountsAmount = discountsAmount;
-        this.total = total;
-    }
-}

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

@@ -1,16 +0,0 @@
-import BaseModel from './base-model';
-
-export default class TransactionModel extends BaseModel {
-    constructor({ invoiceIds = [], ...fields }) {
-        super(fields);
-        this.invoiceIds = invoiceIds || [];
-    }
-
-    get invoiceId() {
-        return this.invoiceIds[0] || null;
-    }
-
-    get hasInvoice() {
-        return !!this.invoiceId;
-    }
-}

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

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

package/src/storefront/payment-instruments.js

@@ -1,47 +0,0 @@
-import { Endpoint } from './index';
-import state from '../state';
-
-export async function setupPaymentInstrument({ data }) {
-    return Endpoint(async () => {
-        // Create payment instrument
-        const { fields: instrument } =
-            await state.storefront.paymentInstruments.create({ data });
-
-        // Setup the payment instrument
-        state.storefront.setSessionToken(instrument.token || state.options.jwt);
-
-        const setupPayload = {
-            id: instrument.id,
-            data: {
-                websiteId: state.options.websiteId,
-                ...data,
-            },
-        };
-
-        if (state.data.amountAndCurrency) {
-            setupPayload.data = {
-                ...setupPayload.data,
-                ...state.data.amountAndCurrency,
-            };
-        }
-
-        if (state.data?.transaction?.redirectUrl) {
-            setupPayload.data.redirectUrl = `${setupPayload.data.redirectUrl}&originalRedirectUrl=${state.data.transaction.redirectUrl}`;
-        }
-
-        const { fields: transaction } =
-            await state.storefront.paymentInstruments.setup(setupPayload);
-
-        return { instrument, transaction };
-    });
-}
-
-export async function fetchPaymentInstrument() {
-    return Endpoint(async () => {
-        const { items: instruments } =
-            await state.storefront.paymentInstruments.getAll({
-                filter: `status:active,inactive,verification-needed`,
-            });
-        return instruments.map(({ fields }) => fields);
-    });
-}

package/src/storefront/payment-instruments.spec.js

@@ -1,88 +0,0 @@
-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';
-
-describe('Storefront API Setup', () => {
-    it('can make purchase', async () => {
-        const instance = new StorefontTestingInstance();
-
-        const paymentInstrumentFields = {
-            id: 'payment-instrument-id',
-        };
-
-        const paymentInstrumentSetupFields = {
-            id: 'payment-instrument-id',
-            approvalUrl: null,
-        };
-
-        const paymentInstrumentPayload = {
-            data: {
-                token: 'test-token',
-            },
-        };
-
-        const paymentInstrumentSetupPayload = {
-            id: paymentInstrumentFields.id,
-            data: {
-                websiteId: 'website-id',
-                currency: 'USD',
-                amount: 30,
-            },
-        };
-
-        when(post(`${storefrontURL}/payment-instruments`)).thenReturn(
-            ok(paymentInstrumentFields),
-        );
-        when(post(`${storefrontURL}/payment-instruments/*/setup`)).thenReturn(
-            ok(paymentInstrumentSetupFields),
-        );
-
-        vi.spyOn(instance.storefront.paymentInstruments, 'create');
-        vi.spyOn(instance.storefront.paymentInstruments, 'setup');
-
-        const paymentInstrumentResponse =
-            await instance.storefront.paymentInstruments.create(
-                paymentInstrumentPayload,
-            );
-
-        const paymentInstrumentSetupResponse =
-            await instance.storefront.paymentInstruments.setup(
-                paymentInstrumentSetupPayload,
-            );
-
-        expect(instance.storefront.paymentInstruments.create).toBeCalledTimes(
-            1,
-        );
-        expect(instance.storefront.paymentInstruments.create).toBeCalledWith(
-            paymentInstrumentPayload,
-        );
-
-        expect(instance.storefront.paymentInstruments.setup).toBeCalledTimes(1);
-        expect(instance.storefront.paymentInstruments.setup).toBeCalledWith(
-            paymentInstrumentSetupPayload,
-        );
-
-        expect(paymentInstrumentResponse.config).toBeInstanceOf(Object);
-        expect(paymentInstrumentResponse.fields).toBeInstanceOf(Object);
-        expect(paymentInstrumentResponse.response).toBeInstanceOf(Object);
-
-        expect(paymentInstrumentResponse.fields).toEqual(
-            paymentInstrumentFields,
-        );
-        expect(paymentInstrumentResponse.fields).toMatchObject(
-            paymentInstrumentFields,
-        );
-
-        expect(paymentInstrumentSetupResponse.config).toBeInstanceOf(Object);
-        expect(paymentInstrumentSetupResponse.fields).toBeInstanceOf(Object);
-        expect(paymentInstrumentSetupResponse.response).toBeInstanceOf(Object);
-
-        expect(paymentInstrumentSetupResponse.fields).toEqual(
-            paymentInstrumentSetupFields,
-        );
-        expect(paymentInstrumentSetupResponse.fields).toMatchObject(
-            paymentInstrumentSetupFields,
-        );
-    });
-});

package/src/storefront/purchase.js

@@ -1,60 +0,0 @@
-import state from '../state';
-import { Endpoint } from './index';
-
-export async function postPurchase({ data }) {
-    return Endpoint(async () => {
-        // https://storefront-api-docs.rebilly.com/tag/Purchases/operation/StorefrontPostPurchase
-        const purchaseSchemaKeys = [
-            'websiteId',
-            'paymentInstruction',
-            'items',
-            'billingAddress',
-            'deliveryAddress',
-            'shippingRateId',
-            'couponIds',
-            'password',
-            'redirectUrl',
-        ];
-        Object.keys(data).forEach((key) => {
-            if (!purchaseSchemaKeys.includes(key)) {
-                delete data[key];
-            }
-        });
-        return state.storefront.purchase.purchase({ data });
-    });
-}
-
-export async function postPayment({ data }) {
-    return Endpoint(async () => {
-        const {
-            token,
-            transactionId,
-            invoiceId,
-            websiteId,
-            paymentInstrumentId,
-        } = data;
-        // https://storefront-api-docs.rebilly.com/tag/Purchases/operation/StorefrontPostPayment
-        const purchaseSchemaKeys = ['riskMetadata', 'redirectUrl'];
-        if (token) {
-            purchaseSchemaKeys.push('token');
-        }
-        if (paymentInstrumentId) {
-            purchaseSchemaKeys.push('paymentInstrumentId');
-        }
-        if (transactionId) {
-            purchaseSchemaKeys.push('transactionId');
-        }
-        if (invoiceId) {
-            purchaseSchemaKeys.push('invoiceId');
-        }
-        if (websiteId) {
-            purchaseSchemaKeys.push('amount', 'currency', 'websiteId');
-        }
-        Object.keys(data).forEach((key) => {
-            if (!purchaseSchemaKeys.includes(key)) {
-                delete data[key];
-            }
-        });
-        return state.storefront.purchase.payment({ data });
-    });
-}

package/src/storefront/purchase.spec.js

@@ -1,53 +0,0 @@
-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';
-
-describe('Storefront API Purchase', () => {
-    it('can make purchase', async () => {
-        const instance = StorefontTestingInstance();
-        const payload = {
-            websiteId: 'test-website-id',
-            items: [
-                {
-                    planId: 'test-plan-id-1',
-                    quantity: 1,
-                },
-            ],
-            billingAddress: {
-                firstName: 'Test',
-                lastName: 'Customer',
-            },
-            paymentInstruction: {
-                token: 'test-token',
-            },
-        };
-        const fields = {
-            orderId: 'test-order-id',
-            invoice: {
-                id: 'test-invoice-id',
-            },
-            transaction: {
-                id: 'test-transaction-id',
-            },
-        };
-
-        when(post(`${storefrontURL}/purchase`)).thenReturn(ok(fields));
-
-        vi.spyOn(instance.storefront.purchase, 'purchase');
-
-        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);
-
-        expect(requestResponse.fields).toEqual(fields);
-        expect(requestResponse.fields).toMatchObject(fields);
-    });
-});

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

@@ -1,96 +0,0 @@
-import { collectData } from '@rebilly/risk-data-collector';
-import { paymentMethods } from '@rebilly/api-metadata';
-import ReadyToPayModel from './models/ready-to-pay-model';
-import { Endpoint } from './index';
-import state from '../state';
-import { mapItemsQuantities } from '../utils/quantity';
-
-export function filterReadyToPay(readyToPay) {
-    const paymentMethodsMetadata = [...paymentMethods];
-    const EXPRESS_METHODS = ['Google Pay', 'Apple Pay', 'paypal'];
-    const BLOCKED_METHODS = [
-        // account number, routing number, and account type required
-        'echeck',
-
-        // payment instrument is required
-        // card number is required
-        // card cvv is required
-        // expiration month is required
-        // expiration year is required
-        'Khelocard',
-
-        // Klarna authorization token is required
-        // Klarna session ID is required
-        'Klarna',
-    ];
-    const isExpressMethod = ({ method, feature }) =>
-        EXPRESS_METHODS.includes(method) ||
-        EXPRESS_METHODS.includes(feature?.name);
-    return readyToPay
-        .filter((readyData) => {
-            // Remove result for "old" paypal method
-            const isOldPayPal =
-                readyData.method === 'paypal' && !readyData.feature;
-            // Remove result for plaid method
-            const isPlaid = readyData.method === 'ach' && readyData.feature;
-            // Remove result for blocked method
-            const isBlocked = BLOCKED_METHODS.includes(readyData.method);
-
-            return !isOldPayPal && !isPlaid && !isBlocked;
-        })
-        .map((fields, index) => {
-            const metadata =
-                paymentMethodsMetadata.find(
-                    (methodMetadata) =>
-                        methodMetadata.apiName === fields.method,
-                ) || {};
-            metadata.isExpressMethod = isExpressMethod(fields);
-
-            return new ReadyToPayModel({
-                index,
-                metadata,
-                ...fields,
-            });
-        })
-        .filter(({ metadata }) => metadata.storefrontEnabled);
-}
-
-export async function fetchReadyToPay() {
-    return Endpoint(async () => {
-        if (!state.data.riskMetadata) {
-            const { riskMetadata: data } = await collectData();
-            state.data.riskMetadata = data;
-        }
-
-        const data = {
-            riskMetadata: state.data.riskMetadata,
-        };
-
-        data.websiteId = state.options?.websiteId || null;
-
-        if (state.options?.items) {
-            data.items = mapItemsQuantities(state.options.items);
-        }
-
-        if (state.options?.money && state.data?.amountAndCurrency) {
-            const money = state.data.amountAndCurrency;
-            data.amount = money.amount;
-            data.currency = money.currency;
-        }
-
-        if (state.data?.account?.address) {
-            data.billingAddress = state.data.account.address;
-        }
-
-        if (state.data?.deposit) {
-            data.amount = state.data.deposit.amount;
-            data.currency = state.data.deposit.currency;
-        }
-
-        const { fields: readyToPayFields } =
-            await state.storefront.purchase.readyToPay({ data });
-        const readyToPay = Object.values(readyToPayFields);
-
-        return filterReadyToPay(readyToPay);
-    });
-}

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

@@ -1,76 +0,0 @@
-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 ReadyToPayModel from './models/ready-to-pay-model';
-import { expectConfigurationError } from 'tests/async-utilities';
-import PaymentMetadataModel from './models/payment-metadata';
-import { paymentMethods } from '@rebilly/api-metadata';
-
-describe('Storefront API Ready to Pay', () => {
-    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,
-                },
-            ],
-        };
-
-        const paymentCardMetadata = [...paymentMethods].find(
-            (method) => method.apiName === 'payment-card',
-        );
-
-        when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(
-            ok(readyToPayPayload),
-        );
-
-        const instance = StorefontTestingInstance({
-            options,
-        });
-
-        vi.spyOn(instance.storefront.purchase, 'readyToPay');
-
-        const response = await fetchReadyToPay({
-            state: instance,
-        });
-
-        expect(instance.storefront.purchase.readyToPay).toBeCalledTimes(1);
-        expect(instance.storefront.purchase.readyToPay).toBeCalledWith({
-            data: expect.objectContaining({
-                items: options.items,
-                websiteId: options.websiteId,
-                riskMetadata: expect.anything(),
-            }),
-        });
-        expect(response).toBeInstanceOf(Array);
-        expect(response[0]).toBeInstanceOf(ReadyToPayModel);
-        expect(response).toEqual([
-            new ReadyToPayModel({
-                index: 0,
-                ...readyToPayPayload[0],
-                metadata: new PaymentMetadataModel(paymentCardMetadata),
-            }),
-        ]);
-    });
-
-    it('should throw errors with no options', async () => {
-        const noConfigOrOptionsInstance = new StorefontTestingInstance({
-            options: null,
-        });
-        await expectConfigurationError(
-            fetchReadyToPay({ state: noConfigOrOptionsInstance }),
-        );
-    });
-});

package/src/storefront/storefront.spec.js

@@ -1,14 +0,0 @@
-import { MockStorefront } from 'tests/mocks/storefront-mock';
-
-describe('Storefront application programming interface', () => {
-    it('can create rebilly-js-sdk instance', () => {
-        const storefront = MockStorefront();
-        expect(storefront).toHaveProperty('setPublishableKey');
-    });
-
-    it('has required endpoints', () => {
-        const storefront = MockStorefront();
-        expect(storefront).toHaveProperty('purchase');
-        expect(storefront.purchase).toHaveProperty('readyToPay');
-    });
-});

package/src/storefront/summary.js

@@ -1,114 +0,0 @@
-import cloneDeep from 'lodash.clonedeep';
-import state from '../state';
-import SummaryModel from './models/summary-model';
-import { Endpoint } from './index';
-import {
-    mapItemsQuantities,
-    createQuantitiesMap,
-    updateItemQuantityFromMap,
-} from '../utils/quantity';
-
-export async function fetchSummary({ data = null } = {}) {
-    return Endpoint(async () => {
-        const items = state.options?.items;
-        const websiteId = state.options?.websiteId || null;
-        const bumpOfferProductsIds =
-            state.options?.bumpOffer?.map(({ planId }) => planId) || [];
-
-        const payload = {
-            data: {
-                websiteId,
-            },
-        };
-
-        const isBumpOfferSummary = () =>
-            state.data.summaryLineItems.every((item) =>
-                bumpOfferProductsIds.includes(item.planId),
-            );
-        if (!isBumpOfferSummary() && !state.data.acceptBumpOffer) {
-            payload.data.items = mapItemsQuantities(
-                state.data.summaryLineItems,
-            );
-        } else if (items) {
-            if (state.data.acceptBumpOffer) {
-                payload.data.items = state.options.bumpOffer;
-            } else {
-                payload.data.items = mapItemsQuantities(items);
-            }
-        } else {
-            payload.data.items = mapItemsQuantities(
-                state.data.summaryLineItems,
-            );
-
-            if (state.data?.addons.length > 0) {
-                payload.data.items = payload.data.items.concat(
-                    state.data.addons.map(mapItemsQuantities),
-                );
-            }
-        }
-
-        if (
-            !state.data.acceptBumpOffer &&
-            state.data?.previewPurchase?.addonLineItems?.length > 0
-        ) {
-            payload.data.items = payload.data.items.concat(
-                state.data.previewPurchase.addonLineItems,
-            );
-        }
-
-        if (state.data?.amountAndCurrency) {
-            payload.data = {
-                ...payload.data,
-                ...state.data.amountAndCurrency,
-            };
-        }
-
-        if (data?.billingAddress) {
-            payload.data.billingAddress = data.billingAddress;
-        }
-
-        if (data?.deliveryAddress) {
-            payload.data.deliveryAddress = data.deliveryAddress;
-        }
-
-        if (state.data?.couponIds) {
-            payload.data.couponIds = state.data.couponIds;
-        }
-
-        const { fields: summaryFields } =
-            await state.storefront.purchase.preview(payload);
-
-        let transformedFields = summaryFields;
-        if (!state.data.acceptBumpOffer) {
-            const quantitiesByPlanId = createQuantitiesMap(items);
-
-            transformedFields = cloneDeep(summaryFields);
-            if (transformedFields.lineItems) {
-                if (state.data?.previewPurchase?.addonLineItems) {
-                    const addonsMap =
-                        state.data.previewPurchase.addonLineItems.reduce(
-                            (map, curr) => {
-                                map.set(curr.planId, curr);
-                                return map;
-                            },
-                            new Map(),
-                        );
-                    transformedFields.lineItems =
-                        transformedFields.lineItems.filter(
-                            (item) => !addonsMap.has(item.planId),
-                        );
-                    transformedFields.addonLineItems =
-                        state.data.previewPurchase.addonLineItems;
-                }
-                transformedFields.lineItems.forEach(
-                    updateItemQuantityFromMap(quantitiesByPlanId),
-                );
-            }
-        }
-
-        // In case of preview purchase gets call again for updating the values
-        state.data.previewPurchase = transformedFields;
-
-        return new SummaryModel(transformedFields);
-    });
-}