@rebilly/instruments 3.29.2 → 3.30.0

package/src/functions/mount/setup-options.js

@@ -1,120 +1,48 @@
-import merge from 'lodash.merge';
 import decodeJwt from 'jwt-decode';
+import merge from 'lodash.merge';
 import { parseQuantity } from '../../utils/quantity';
+import { validateOptions } from '../../data/options-schema';
 
-export const defaults = {
-  countryCode: 'US',
-  locale: 'auto',
-  theme: {
-    labels: 'stacked'
-  },
-  addons: [],
-  bumpOffer: [],
-  paymentInstruments: {
-    address: {
-      name: 'default',
-      region: 'default',
-      hide: [],
-      show: [],
-      require: []
-    },
-    compactExpressInstruments: false,
-    googlePay: {
-      displayOptions: {
-        buttonColor: 'black',
-        buttonType: 'plain',
-        buttonHeight: '48px'
-      }
-    },
-    applePay: {
-      displayOptions: {
-        buttonColor: 'black',
-        buttonType: 'plain',
-        buttonHeight: '48px'
-      }
-    },
-    paymentCard: {
-      popup: false
-    },
-    paypal: {
-      buttonHeight: 48,
-    }
-  },
-  transactionType: 'purchase',
-  features: {
-    autoConfirmation: true,
-    autoResult: true,
-    showCoupons: null,
-  }
-};
-
-export function sanitizeOptions(options) {
-  // TODO: Additional sanitization
-
-  // cast options to be only json object
-  return JSON.parse(
-    JSON.stringify(options)
-  )
+export function handleComputedProperty(options) {
+  const _computed = {
+    paymentMethodsUrl: options._dev?.paymentMethodsUrl ?? 'https://forms.secure-payments.app'
+  };
+  options._computed = _computed;
+  return options 
 }
 
-export function validateOptions(options) {
-  // TODO: validate more options
-  const purchaseData = [
-    options.items,
-    options.invoiceId,
-    options.money,
-    options.transactionId,
-  ].filter(v => v);
-
-  if (!options.jwt && purchaseData.length === 0) {
-    throw new Error('Must provide purchase data');
+export function handleNestedPropertiesDefaultValues(options) {
+  /*
+    The JSON Schema default property doesn't work on nested schemas.
+    So we'll need to handle the default properties in these instances.
+    In most cases default property in schema is sufficient.
+
+    see https://ajv.js.org/guide/modifying-data.html#assigning-defaults
+  */
+  if (options.deposit?.currency) {
+    options.deposit = merge({
+      editable: true,
+      buttons: [],
+      customAmount: {
+        minimum: 1,
+        maximum: Number.MAX_SAFE_INTEGER,
+        increment: 1,
+      }
+    }, (options.deposit || {}));
   }
 
-  if (purchaseData.length > 1) {
-    throw new Error('Must provide only one purchase data type');
+  if (options.items) {
+    options.items = options.items.map(item => ({
+      ...item,
+      quantity: parseQuantity(item)
+    }));
   }
 
-  if (!options.jwt && (options.invoiceId || options.transactionId)) {
-    throw new Error('Must provide a jwt');
-  }
+  return options;
 }
 
-export default ({
-  options = {}
-} = {}) => {
-  const sanitizedOptions = sanitizeOptions(options);
-
-  validateOptions(sanitizedOptions);
-
-  const _computed = {
-    paymentMethodsUrl: sanitizedOptions._dev
-      ? sanitizedOptions._dev.paymentMethodsUrl || 'https://forms.local.rebilly.dev:3000'
-      : 'https://forms.secure-payments.app'
-  };
-
-  const combinedOptions = merge({ ...defaults }, {
-    apiMode: sanitizedOptions.apiMode,
-    i18n: sanitizedOptions.i18n,
-    theme: sanitizedOptions.theme,
-    css: sanitizedOptions.css,
-    locale: sanitizedOptions.locale,
-    countryCode: sanitizedOptions.countryCode,
-    features: sanitizedOptions.features,
-    paymentInstruments: sanitizedOptions.paymentInstruments,
-    transactionType: sanitizedOptions.transactionType,
-    _computed
-  });
-
-  if (sanitizedOptions.publishableKey) {
-    Object.entries({
-      organizationId: sanitizedOptions.organizationId,
-      publishableKey: sanitizedOptions.publishableKey,
-      websiteId: sanitizedOptions.websiteId,
-    }).forEach(([key, value]) => {
-      combinedOptions[key] = value;
-    });
-  } else if (sanitizedOptions.jwt) {
-    combinedOptions.jwt = sanitizedOptions.jwt;
+export function handleJwtDestructuring(options) {
+  if (options.jwt && !options.publishableKey) {
     const {
       merchant: organizationId,
       claims: {
@@ -122,53 +50,30 @@ export default ({
         invoiceId,
         websiteId,
       }
-    } = decodeJwt(combinedOptions.jwt);
-
-    combinedOptions.organizationId = organizationId;
-
-    if (transactionId) {
-      combinedOptions.transactionId = transactionId;
-    }
-
-    if (invoiceId) {
-      combinedOptions.invoiceId = invoiceId;
-    }
-
-    if (websiteId) {
-      combinedOptions.websiteId = websiteId;
-    }
-  }
-
-  if (options.items) {
-    combinedOptions.items = options.items.map(item => ({
-      ...item,
-      quantity: parseQuantity(item)
-    }));
+    } = decodeJwt(options.jwt);
+    Object.entries({
+      organizationId,
+      transactionId,
+      invoiceId,
+      websiteId
+    }).forEach(([key, value]) => {
+      if (Boolean(value)) {
+        options[key] = value;
+      }
+    });
   }
-  
-  // Add optional key's
-  [
-    'money',
-    'invoiceId',
-    'transactionId',
-    'jwt',
-    '_dev'
-  ].forEach(key => {
-    if (options[key]) {
-      combinedOptions[key] = options[key];
-    }
-  });
 
-  // only add "addons" or "bumpOffer" if items are available
-  if (combinedOptions.items) {
-    if (options.addons) {
-      combinedOptions.addons = options.addons;
-    }
+  return options;
+}
 
-    if (options.bumpOffer) {
-      combinedOptions.bumpOffer = options.bumpOffer;
-    }
+export default ({
+  options = {}
+} = {}) => {
+  let validOptions = validateOptions(options);
+  if (validOptions) {
+    validOptions = handleComputedProperty(validOptions);
+    validOptions = handleNestedPropertiesDefaultValues(validOptions);
+    validOptions = handleJwtDestructuring(validOptions);
   }
-
-  return combinedOptions;
+  return validOptions;
 }

package/src/functions/mount/setup-options.spec.js

@@ -1,124 +1,317 @@
-import { RenderMockRebillyInstruments } from 'tests/mocks/rebilly-instruments-mock';
-import setupOptions, {validateOptions, defaults, sanitizeOptions} from './setup-options';
-
-describe('Setup mount options', () => {
-  it("should fill with default options", () => {
-    const options = setupOptions({
-      options: {
-        items: [
-          {
-            planId: "test-plan-id",
-            quantity: 1
-          }
-        ]
+import { RebillyInstrumentsConfigError } from '../../data/options-schema';
+import setupOptions, {
+  handleComputedProperty,
+  handleNestedPropertiesDefaultValues,
+  handleJwtDestructuring
+} from './setup-options';
+
+describe('Setup options function', () => {
+  it('should throw error when options are invalid', () => {
+      jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      expect(() => setupOptions()).toThrow(RebillyInstrumentsConfigError);
+  });
+
+  it ('should expect only one purchase data', () => {
+    const errorLogs = [];
+    jest.spyOn(console, 'error').mockImplementation((error) => {
+      if (typeof error === 'object') {
+        errorLogs.push(error.message);
       }
     });
-    expect(options).toMatchObject(defaults);
+    
+    const options = {
+      apiMode: 'sandbox',
+      items: [{
+        planId: 'plan_TEST',
+        quantity: 1
+      }],
+      money: {
+        amount: 1.99,
+        currency: 'USD'
+      }
+    }
+    expect(() => setupOptions({options})).toThrow(RebillyInstrumentsConfigError);
+    expect(errorLogs.length).toEqual(1);
+    expect(errorLogs[0]).toEqual('options must match exactly one schema in oneOf, see schemas below.');
   });
 
-  it("should setup options from mount", async () => {
+  it.only('should validate and inject default values', () => {
+    const testJwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJqd3RfVEVTVC1BIiwiZXhwIjoxNzE0ODQwNDg5LCJpYXQiOjE2ODMyMTY1ODkuNTYwMjU2LCJhY2wiOlt7InNjb3BlIjp7Im9yZ2FuaXphdGlvbklkIjpbIm9yZ19URVNULUEiXSwiaW52b2ljZUlkIjpbImluX1RFU1QtQSJdLCJjdXN0b21GaWVsZE5hbWUiOlsiU0lOTGFzdDQiXX0sInBlcm1pc3Npb25zIjpbMjg0LDI4Niw0MTQsNDE1LDQzNCw0MTIsNDI0LDQyNSw0MjYsNDI3LDQyOCw0MjksNDA5LDQxMCw0MDEsNDAyLDQzMyw0MzFdfV0sImNsYWltcyI6eyJ3ZWJzaXRlSWQiOiJ3ZWJfVEVTVC1BIiwiaW52b2ljZUlkIjoiaW5fVEVTVC1BIiwicGF5bWVudE1ldGhvZHMiOltdfSwibWVyY2hhbnQiOiJNRVJDSEFOVC1URVNULUlELUEiLCJjdXN0b21lciI6eyJpZCI6ImN1c19URVNULUEiLCJuYW1lIjoiQ2FyZCBIb2xkZXIgTmFtZSIsImNyZWF0ZWRUaW1lIjoiMjAyMi0wOS0yMVQxODo1MDoyMiswMDowMCJ9fQ.tm33uioGUSpEedHeYufDGm-p1YW40eufNovppcU6-xg';
     const options = {
-      publishableKey: 'test-publishable-key',
-      organizationId: 'test-organization-id',
-      websiteId: 'test-website-id',
-      jwt: 'test-jwt'
+      jwt: testJwt,
+      apiMode: 'sandbox',
+      items: [{
+        planId: 'plan_TEST',
+        quantity: {},
+      }]
     }
-    const rebillyInstruments = await RenderMockRebillyInstruments(options);
-    expect(rebillyInstruments.state.options).toMatchObject(options);
+
+    const results = setupOptions({options});
+
+    expect(results).toEqual({
+      jwt: testJwt,
+      apiMode: 'sandbox',
+      items: [{
+        planId: 'plan_TEST',
+        quantity: {
+          minimum: 1,
+          maximum: Number.MAX_SAFE_INTEGER,
+          multipleOf: 1
+        }
+      }],
+      form: '.rebilly-instruments',
+      summary: '.rebilly-instruments-summary',
+      addons: [],
+      bumpOffer: [],
+      transactionType: 'purchase',
+      theme: { labels: 'stacked' },
+      countryCode: 'US',
+      locale: 'auto',
+      paymentInstruments: {
+        compactExpressInstruments: false,
+        address: {
+          name: 'default',
+          region: 'default',
+          show: [],
+          hide: [],
+          require: []
+        },
+        paypal: { buttonHeight: 48 },
+        googlePay: {
+          displayOptions: {
+            buttonColor: 'black',
+            buttonHeight: '48px',
+            buttonType: 'plain'
+          }
+        },
+        applePay: {
+          displayOptions: {
+            buttonColor: 'black',
+            buttonHeight: '48px',
+            buttonType: 'plain'
+          }
+        },
+        paymentCard: { popup: false }
+      },
+      features: { autoConfirmation: true, autoResult: true },
+      _computed: { paymentMethodsUrl: 'https://forms.secure-payments.app' },
+      organizationId: 'MERCHANT-TEST-ID-A',
+      invoiceId: 'in_TEST-A',
+      websiteId: 'web_TEST-A'
+    });
+  })
+
+  describe ('should throw error for missing purchase data', () => {
+    const errorLogs = [];
+    jest.spyOn(console, 'error').mockImplementation((error) => {
+      if (typeof error === 'string') {
+        errorLogs.push(error);
+      }
+    });
+    
+    expect(() => setupOptions()).toThrow(RebillyInstrumentsConfigError);
+    expect(errorLogs.length).toEqual(6);
+    const expectedResults = [
+      'items',
+      'money',
+      'invoiceId',
+      'transactionId',
+      'deposit',
+      'jwt'
+    ]
+    expectedResults.forEach(result => {
+      it (`should expect required oneOf ${result}`, () => {
+        expect(errorLogs.some((error) => {
+          return (error.includes('required') && error.includes(result));
+        })).toEqual(true);
+      });
+    });
+  });
+
+  describe('should ensure purchase data has dependant properties', () => {
+    let errorLogs = [];
+    beforeEach(() => {
+      errorLogs = [];
+      jest.spyOn(console, 'error').mockImplementation((error) => {
+        if (typeof error === 'object') {
+          errorLogs.push(error.message);
+        }
+      });
+    });
+
+    const expectJwtTests = [
+      {
+        invoiceId: 'in_TEST'
+      },
+      {
+        transactionId: 'txn_TEST'
+      },
+      {
+        deposit: {
+          depositRequestId: 'cash_req_TEST'
+        }
+      }
+    ]
+
+    expectJwtTests.forEach(test => {
+      const key = Object.keys(test)[0];
+      it(`should expect jwt with ${key}`, () => {
+        const options = {
+          apiMode: 'sandbox',
+          ...test
+        }
+  
+        expect(() => setupOptions({options})).toThrow(RebillyInstrumentsConfigError);
+        expect(errorLogs.length).toEqual(1);
+        expect(errorLogs[0]).toEqual(`options must have property jwt when property ${key} is present`);
+      })
+    });
   });
 });
 
-describe('Validate mount options', () => {
-  it("should throw an error with no purchase data", async () => {
-    let error = null;
-    try {
-      const options = {};
-      validateOptions(options);
-    } catch (e) {
-      error = e;
+describe('Setup options handleComputedProperty function', () => {
+  it('should populate options with instrument methods url', () => {
+    const options = {}
+    const result = handleComputedProperty(options);
+
+    expect(result).toEqual({
+      _computed: { paymentMethodsUrl: 'https://forms.secure-payments.app' }
+    });
+  });
+
+  it('should set paymentMethodsUrl from _dev configuration', () => {
+    const options = {
+      _dev: {
+        paymentMethodsUrl: 'https://www.example.com'
+      }
     }
-    expect(error.message).toBe('Must provide purchase data');
+    const result = handleComputedProperty(options);
+
+    expect(result._computed.paymentMethodsUrl).toEqual('https://www.example.com');
   });
 
-  it("should throw error if there are more than one purchase property", () => {
-    let error = null;
-    try {
-      const options = {
-        invoiceId: "test-invoice-id",
-        items: [{
-          planId: "test-plan-id",
-          quantity: 1
-        }]
-      };
-      validateOptions(options);
-    } catch (e) {
-      error = e;
+  it('should default paymentMethodsUrl from empty _dev configuration', () => {
+    const options = {
+      _dev: {}
     }
-    expect(error.message).toBe('Must provide only one purchase data type');
+    const result = handleComputedProperty(options);
+
+    expect(result._computed.paymentMethodsUrl).toEqual('https://forms.secure-payments.app');
   });
 });
 
-describe('sanitize mount options', () => {
-  it('should make into object', () => {
-    class options {
-      constructor() {
-        this.items = [
-          {
-            planId: "test-plan-id",
-            quantity: 1
-          }
-        ];
+describe('Setup options handleNestedPropertiesDefaultValues function', () => {
+  it('should add defaults for deposits with currency configuration', () => {
+    const options = {
+      deposit: {
+        currency: 'USD',
+      },
+    };
+
+    const result = handleNestedPropertiesDefaultValues(options);
+
+    expect(result).toEqual({
+      deposit: {
+        editable: true,
+        buttons: [],
+        customAmount: {
+          minimum: 1,
+          maximum: Number.MAX_SAFE_INTEGER,
+          increment: 1,
+        },
+        currency: 'USD'
+      }
+    });
+  });
+
+  it('should not inject defaults to deposit without currency', () => {
+    const options = {
+      deposit: {
+        depositRequestId: 'cash_req_TEST'
       }
     }
 
-    expect(setupOptions({
-      options: new options()
-    })).toMatchObject(defaults);
+    const result = handleNestedPropertiesDefaultValues(options);
+    expect(result).toEqual({
+      deposit: {
+        depositRequestId: 'cash_req_TEST'
+      }
+    });
   });
 
-  it('should merge class and default object', () => {
-    class options {
-      constructor() {
-        this.items = [
-          {
-            planId: "test-plan-id",
-            quantity: 1
-          }
-        ];
+  it('should add defaults to items with empty object for quantity', () => {
+    const options = {
+      items: [{
+        planId: 'plan_TEST',
+        quantity: {}
+      }]
+    };
 
-        this.features = {
-          showCoupons: ['summary'],
-          other: 'key'
+    const result = handleNestedPropertiesDefaultValues(options);
+    expect(result).toEqual({
+      items: [{
+        planId: 'plan_TEST',
+        quantity: {
+          minimum: 1,
+          maximum: Number.MAX_SAFE_INTEGER,
+          multipleOf: 1
         }
-      }
-    }
+      }]
+    });
+  })
+});
 
-    expect(setupOptions({
-      options: new options()
-    })).toMatchObject(
-      expect.objectContaining({
-        features: expect.objectContaining({
-          ...defaults.features,
-          showCoupons: ['summary'],
-          other: 'key'
-        })
-      })
-    );
+describe('Setup options handleJwtDestructuring function', () => {
+  const testJwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJqd3RfVEVTVC1BIiwiZXhwIjoxNzE0ODQwNDg5LCJpYXQiOjE2ODMyMTY1ODkuNTYwMjU2LCJhY2wiOlt7InNjb3BlIjp7Im9yZ2FuaXphdGlvbklkIjpbIm9yZ19URVNULUEiXSwiaW52b2ljZUlkIjpbImluX1RFU1QtQSJdLCJjdXN0b21GaWVsZE5hbWUiOlsiU0lOTGFzdDQiXX0sInBlcm1pc3Npb25zIjpbMjg0LDI4Niw0MTQsNDE1LDQzNCw0MTIsNDI0LDQyNSw0MjYsNDI3LDQyOCw0MjksNDA5LDQxMCw0MDEsNDAyLDQzMyw0MzFdfV0sImNsYWltcyI6eyJ3ZWJzaXRlSWQiOiJ3ZWJfVEVTVC1BIiwiaW52b2ljZUlkIjoiaW5fVEVTVC1BIiwicGF5bWVudE1ldGhvZHMiOltdfSwibWVyY2hhbnQiOiJNRVJDSEFOVC1URVNULUlELUEiLCJjdXN0b21lciI6eyJpZCI6ImN1c19URVNULUEiLCJuYW1lIjoiQ2FyZCBIb2xkZXIgTmFtZSIsImNyZWF0ZWRUaW1lIjoiMjAyMi0wOS0yMVQxODo1MDoyMiswMDowMCJ9fQ.tm33uioGUSpEedHeYufDGm-p1YW40eufNovppcU6-xg';
+  
+  it('should destructure when jwt is present', () => {
+    const options = {
+      jwt: testJwt,
+    };
+
+    const result = handleJwtDestructuring(options);
+    expect(result).toEqual({
+      jwt: testJwt,
+      organizationId: 'MERCHANT-TEST-ID-A',
+      invoiceId: 'in_TEST-A',
+      websiteId: 'web_TEST-A'
+    });
   });
 
-  it ('should sanitize class to object', () => {
-    class OptionsClass {
-      constructor() {
-        this.key = "value"
-      }
-    }
+  it('should not destructure when publishableKey is supplied', () => {
+    const options = {
+      jwt: testJwt,
+      publishableKey: 'pk_sandbox_TEST',
+      organizationId: 'MERCHANT-TEST-ID-B',
+      invoiceId: 'in_TEST-B',
+      websiteId: 'web_TEST-B'
+    };
+
+    const result = handleJwtDestructuring(options);
+    expect(result).toEqual({
+      jwt: testJwt,
+      publishableKey: 'pk_sandbox_TEST',
+      organizationId: 'MERCHANT-TEST-ID-B',
+      invoiceId: 'in_TEST-B',
+      websiteId: 'web_TEST-B'
+    });
+  });
 
-    const newOptions = new OptionsClass();
+  it('should use JWT values when publishableKey is missing', () => {
+    const options = {
+      jwt: testJwt,
+      organizationId: 'MERCHANT-TEST-ID-B',
+      invoiceId: 'in_TEST-B',
+      websiteId: 'web_TEST-B'
+    };
 
-    expect(sanitizeOptions(newOptions)).toMatchObject({
-      key: 'value'
+    const result = handleJwtDestructuring(options);
+    expect(result).toEqual({
+      jwt: testJwt,
+      organizationId: 'MERCHANT-TEST-ID-A',
+      invoiceId: 'in_TEST-A',
+      websiteId: 'web_TEST-A'
     });
-    expect(sanitizeOptions(newOptions)).toBeInstanceOf(Object);
-    expect(sanitizeOptions(newOptions)).not.toBeInstanceOf(OptionsClass);
-  })
+  });
 });

package/src/functions/update.js

@@ -3,25 +3,6 @@ import state from '../state';
 import { destroy } from './destroy';
 import { mount } from './mount';
 
-function sanitizeOldPurchaseData({newOptions}) {
-  let purchaseData = {};
-  const hasPurchaseDataKeys = Object.keys(newOptions).some(key => [
-    'items',
-    'money',
-    'invoiceId',
-    'transactionId'
-  ].includes(key));
-
-  purchaseData = hasPurchaseDataKeys ? {
-    items: null,
-    money: null,
-    invoiceId: null,
-    transactionId: null
-  } : purchaseData;
-
-  return purchaseData;
-};
-
 export async function update({newOptions = {}}) {
   if (!state.hasMounted) {
     throw Error('Update method cannot be called before mounting instruments');
@@ -45,12 +26,7 @@ export async function update({newOptions = {}}) {
   //   return;
   // }
 
-  const oldOptions = {
-    ...state.options,
-    ...sanitizeOldPurchaseData({newOptions})
-  };
-
-  const updatedOptions = merge({...oldOptions}, newOptions);
+  const updatedOptions = merge({...state.options}, newOptions);
 
   await destroy();
 

package/src/functions/update.spec.js

@@ -68,6 +68,7 @@ describe('RebillyInstruments Update', () => {
     expect(rebillyInstruments.state.options.countryCode).toEqual('ES');
     await avoidUnhandledPromises();
   });
+
   it('should replace the items with different options', async () => {
     const rebillyInstruments = await RenderMockRebillyInstruments();
     const formElement = document.querySelector('.form-selector');