@rebilly/instruments 4.4.0 → 4.6.0

package/src/storefront/payment-instruments.js

@@ -2,43 +2,46 @@ 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};
-  });
+    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 Endpoint(async () => {
+        const { items: instruments } =
+            await state.storefront.paymentInstruments.getAll({
+                filter: `status:active,inactive,verification-needed`,
+            });
+        return instruments.map(({ fields }) => fields);
     });
-    return instruments.map(({fields}) => fields);
-  });
 }

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

@@ -4,66 +4,85 @@ 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);
-  });
+    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

@@ -2,53 +2,59 @@ 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 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 });
     });
-    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 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 });
     });
-    return state.storefront.purchase.payment({data});
-  });
 }

package/src/storefront/purchase.spec.js

@@ -4,50 +4,50 @@ 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'
-      }
-    };
+    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));
+        when(post(`${storefrontURL}/purchase`)).thenReturn(ok(fields));
 
-    vi.spyOn(instance.storefront.purchase, 'purchase');
+        vi.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(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.config).toBeInstanceOf(Object);
+        expect(requestResponse.fields).toBeInstanceOf(Object);
+        expect(requestResponse.response).toBeInstanceOf(Object);
 
-    expect(requestResponse.fields).toEqual(fields);
-    expect(requestResponse.fields).toMatchObject(fields);
-  });
+        expect(requestResponse.fields).toEqual(fields);
+        expect(requestResponse.fields).toMatchObject(fields);
+    });
 });

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

@@ -6,93 +6,91 @@ 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',
+    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)
+        // payment instrument is required
+        // card number is required
+        // card cvv is required
+        // expiration month is required
+        // expiration year is required
+        'Khelocard',
 
-      return !isOldPayPal && !isPlaid && !isBlocked
-    })
-    .map((fields, index) => {
-      const metadata = paymentMethodsMetadata
-        .find(methodMetadata => methodMetadata.apiName === fields.method) || {};
-      metadata.isExpressMethod = isExpressMethod(fields);
+        // 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 new ReadyToPayModel({
-        index,
-        metadata,
-        ...fields
-      });
-    })
-    .filter(({metadata}) => metadata.storefrontEnabled);
+            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({
-  riskMetadata = null,
-}) {
-  return Endpoint(async () => {
-    if (!riskMetadata) {
-      const { riskMetadata: data } = await collectData();
-      riskMetadata = data;
-    }
+export async function fetchReadyToPay({ riskMetadata = null }) {
+    return Endpoint(async () => {
+        if (!riskMetadata) {
+            const { riskMetadata: data } = await collectData();
+            riskMetadata = data;
+        }
+
+        const data = {
+            riskMetadata,
+        };
 
-    const data = {
-      riskMetadata
-    };
+        data.websiteId = state.options?.websiteId || null;
 
-    data.websiteId = state.options?.websiteId || null;
+        if (state.options?.items) {
+            data.items = mapItemsQuantities(state.options.items);
+        }
 
-    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.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?.account?.address) {
-      data.billingAddress = state.data.account.address;
-    }
+        if (state.data?.deposit) {
+            data.amount = state.data.deposit.amount;
+            data.currency = state.data.deposit.currency;
+        }
 
-    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);
 
-    const { fields: readyToPayFields } = await state.storefront.purchase.readyToPay({ data });
-    const readyToPay = Object.values(readyToPayFields);
-    
-    return filterReadyToPay(readyToPay);
-  });
+        return filterReadyToPay(readyToPay);
+    });
 }