swell-js 5.1.2 → 5.2.0

package/dist/payment.mjs

@@ -21,6 +21,7 @@ const SCRIPT_HANDLERS = {
   'braintree-google-payment': loadBraintreeGoogle,
   'braintree-apple-payment': loadBraintreeApple,
   'amazon-checkout': loadAmazonCheckout,
+  'sezzle-sdk': loadSezzleCheckout,
 };
 
 const BRAINTREE_VERSION = '3.91.0';
@@ -188,6 +189,19 @@ async function loadAmazonCheckout() {
   }
 }
 
+async function loadSezzleCheckout() {
+  if (!window.Checkout) {
+    await loadScript(
+      'sezzle-sdk',
+      'https://checkout-sdk.sezzle.com/express_checkout.min.js',
+    );
+  }
+
+  if (!window.Checkout) {
+    console.error('Warning: Sezzle Checkout was not loaded');
+  }
+}
+
 async function loadScripts(scripts) {
   if (!scripts) {
     return;
@@ -441,8 +455,8 @@ class Payment {
   /**
    * Calls the onSuccess handler.
    *
-   * @param {object | undefined} data
-   * @returns {any}
+   * @param {unknown} [data]
+   * @returns {unknown}
    */
   onSuccess(data) {
     const successHandler = get(this.params, 'onSuccess');
@@ -455,7 +469,7 @@ class Payment {
   /**
    * Calls the onCancel handler.
    *
-   * @returns {any}
+   * @returns {unknown}
    */
   onCancel() {
     const cancelHandler = get(this.params, 'onCancel');
@@ -469,7 +483,7 @@ class Payment {
    * Calls the onError handler.
    *
    * @param {Error} error
-   * @returns {any}
+   * @returns {unknown}
    */
   onError(error) {
     const errorHandler = get(this.params, 'onError');
@@ -1983,6 +1997,107 @@ class BraintreePaypalPayment extends Payment {
   }
 }
 
+/** @typedef {import('../../types').Cart} Cart */
+/** @typedef {import('../../types').Discount} Discount */
+
+function adjustConfig(params) {
+  if (!params.config) {
+    return;
+  }
+
+  if (params.card) {
+    console.warn('Please move the "config" field to the "card.config"');
+
+    params.card.config = params.config;
+  }
+
+  if (params.ideal) {
+    console.warn('Please move the "config" field to the "ideal.config"');
+
+    params.ideal.config = params.config;
+  }
+
+  delete params.config;
+}
+
+function adjustElementId(methodParams) {
+  if (methodParams.cardNumber) {
+    adjustElementId(methodParams.cardNumber);
+  }
+
+  if (methodParams.cardExpiry) {
+    adjustElementId(methodParams.cardExpiry);
+  }
+
+  if (methodParams.cardCvc) {
+    adjustElementId(methodParams.cardCvc);
+  }
+
+  if (!methodParams.elementId) {
+    return;
+  }
+
+  if (methodParams.elementId.startsWith('#')) {
+    console.warn(
+      `Please remove the "#" sign from the "${methodParams.elementId}" element ID`,
+    );
+
+    methodParams.elementId = methodParams.elementId.substring(1);
+  }
+}
+
+function adjustParams(_params) {
+  const params = { ..._params };
+
+  adjustConfig(params);
+
+  return params;
+}
+
+function adjustMethodParams(_methodParams) {
+  const methodParams = { ..._methodParams };
+
+  adjustElementId(methodParams);
+
+  return methodParams;
+}
+
+/**
+ * @param {Discount} discount
+ * @param {Cart} cart
+ */
+function getDiscountLabel(discount, cart) {
+  switch (discount.type) {
+    case 'coupon': {
+      const { coupon } = cart;
+
+      if (coupon?.name) {
+        return coupon.name;
+      }
+
+      break;
+    }
+
+    case 'promo': {
+      const { promotions } = cart;
+
+      if (Array.isArray(promotions?.results)) {
+        const promo = promotions.results.find(
+          (promo) => promo.id === discount.source_id,
+        );
+
+        if (promo?.name) {
+          return promo?.name;
+        }
+      }
+
+      break;
+    }
+  }
+
+  return discount.id;
+}
+
 /** @typedef {import('./payment').default} Payment */
 /** @typedef {import('../../types').Cart} Cart */
 /** @typedef {import('../../types').Address} Address */
@@ -2025,7 +2140,7 @@ async function onPaymentDataChanged(intermediatePaymentData) {
 
         // Update cart with new shipping address and force tax recalculation
         let cart = await this.updateCart({
-          shipping: convertToSwellAddress$1(
+          shipping: convertToSwellAddress$2(
             intermediatePaymentData.shippingAddress,
           ),
         });
@@ -2118,42 +2233,6 @@ async function onPaymentDataChanged(intermediatePaymentData) {
   return {};
 }
 
-/**
- * @param {Discount} discount
- * @param {Cart} cart
- */
-function getDiscountLabel(discount, cart) {
-  switch (discount.type) {
-    case 'coupon': {
-      const { coupon } = cart;
-
-      if (coupon?.name) {
-        return coupon.name;
-      }
-
-      break;
-    }
-
-    case 'promo': {
-      const { promotions } = cart;
-
-      if (Array.isArray(promotions?.results)) {
-        const promo = promotions.results.find(
-          (promo) => promo.id === discount.source_id,
-        );
-
-        if (promo?.name) {
-          return promo?.name;
-        }
-      }
-
-      break;
-    }
-  }
-
-  return discount.id;
-}
-
 /**
  * Converts cart data to Google Pay display items for the payment sheet.
  * Only works when payment callbacks are properly configured.
@@ -2311,7 +2390,7 @@ function getOfferInfo(cart) {
  * @param {google.payments.api.Address} address
  * @returns {Address}
  */
-function convertToSwellAddress$1(address) {
+function convertToSwellAddress$2(address) {
   return {
     name: address.name,
     address1: address.address1,
@@ -2572,10 +2651,10 @@ class BraintreeGooglePayment extends Payment {
           nonce,
           gateway: 'braintree',
         },
-        ...convertToSwellAddress$1(billingAddress),
+        ...convertToSwellAddress$2(billingAddress),
       },
       ...(requireShipping && {
-        shipping: convertToSwellAddress$1(shippingAddress),
+        shipping: convertToSwellAddress$2(shippingAddress),
       }),
     });
 
@@ -2612,7 +2691,7 @@ async function onShippingContactSelected(session, event) {
     // Update cart with Apple Pay shipping address to get shipping options and tax
     // This happens immediately when the sheet opens with the default address
     const cart = await this.updateCart({
-      shipping: convertToSwellAddress(event.shippingContact),
+      shipping: convertToSwellAddress$1(event.shippingContact),
     });
 
     if (!cart.shipment_rating?.services?.length) {
@@ -2854,7 +2933,7 @@ function getShippingMethods(cart) {
  * @param {ApplePayJS.ApplePayPaymentContact} [address]
  * @returns {Address}
  */
-function convertToSwellAddress(address = {}) {
+function convertToSwellAddress$1(address = {}) {
   return {
     first_name: address.givenName,
     last_name: address.familyName,
@@ -3059,10 +3138,10 @@ class BraintreeApplePayment extends Payment {
             nonce: payload.nonce,
             gateway: 'braintree',
           },
-          ...convertToSwellAddress(billingContact),
+          ...convertToSwellAddress$1(billingContact),
         },
         ...(requireShipping && {
-          shipping: convertToSwellAddress(shippingContact),
+          shipping: convertToSwellAddress$1(shippingContact),
         }),
       });
 
@@ -3240,7 +3319,7 @@ class AuthorizeNetGooglePayment extends Payment {
       throw new Error('Payment token is missing');
     }
 
-    const cart = await this.updateCart({
+    await this.updateCart({
       account: {
         email,
       },
@@ -3252,14 +3331,14 @@ class AuthorizeNetGooglePayment extends Payment {
           gateway: 'authorizenet',
           token: base64Encode(token),
         },
-        ...convertToSwellAddress$1(billingAddress),
+        ...convertToSwellAddress$2(billingAddress),
       },
       ...(requireShipping && {
-        shipping: convertToSwellAddress$1(shippingAddress),
+        shipping: convertToSwellAddress$2(shippingAddress),
       }),
     });
 
-    this.onSuccess(cart);
+    this.onSuccess();
   }
 
   /**
@@ -3541,7 +3620,7 @@ class AuthorizeNetApplePayment extends Payment {
         //
         // We store the payment token but DO NOT process the order yet.
         // The user must manually click "Place Order" to complete the transaction.
-        const cart = await this.updateCart({
+        await this.updateCart({
           account: {
             email: shippingContact.emailAddress,
           },
@@ -3553,10 +3632,10 @@ class AuthorizeNetApplePayment extends Payment {
               token: base64Encode(JSON.stringify(token.paymentData)),
               gateway: 'authorizenet',
             },
-            ...convertToSwellAddress(billingContact),
+            ...convertToSwellAddress$1(billingContact),
           },
           ...(requireShipping && {
-            shipping: convertToSwellAddress(shippingContact),
+            shipping: convertToSwellAddress$1(shippingContact),
           }),
         });
 
@@ -3569,7 +3648,7 @@ class AuthorizeNetApplePayment extends Payment {
         // Notify that Apple Pay authorization is complete
         // The cart now has the payment token and is ready for submission
         // NOTE: This does NOT submit the order - user must click "Place Order"
-        this.onSuccess(cart);
+        this.onSuccess();
       } catch (err) {
         session.completePayment({
           status: this.ApplePaySession.STATUS_FAILURE,
@@ -4395,66 +4474,438 @@ class AmazonDirectPayment extends Payment {
   }
 }
 
-function adjustConfig(params) {
-  if (!params.config) {
-    return;
+/** @typedef {import('../../../types').Cart} Cart */
+/** @typedef {import('../../../types').Address} Address */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutPayloadOrderAmount
+ * @prop {number} amount_in_cents
+ * @prop {string} currency
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutPayloadOrderItem
+ * @prop {string} name
+ * @prop {string} sku
+ * @prop {number} quantity
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrderAmount} price
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutPayloadOrderDiscount
+ * @prop {string} name
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrderAmount} amount
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutPayloadOrder
+ * @prop {'AUTH' | 'CAPTURE'} intent
+ * @prop {string} reference_id
+ * @prop {string} description
+ * @prop {boolean} requires_shipping_info
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrderItem[]} items
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrderDiscount[]} discounts
+ * @prop {Record<string, string>} [metadata]
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrderAmount} tax_amount
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrderAmount} order_amount
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutPayloadData
+ * @prop {'single-step' | 'multi-step' | 'no-shipping'} express_checkout_type
+ * @prop {SezzleCheckoutSdkCheckoutPayloadOrder} order
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutPayload
+ * @prop {SezzleCheckoutSdkCheckoutPayloadData} checkout_payload
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutUrl
+ * @prop {string} checkout_url
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutShippingAddress
+ * @prop {string} uuid
+ * @prop {string} name
+ * @prop {string} street
+ * @prop {string} street2
+ * @prop {string} city
+ * @prop {string} state
+ * @prop {string} postal_code
+ * @prop {string} country_code
+ * @prop {string} phone
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutShippingError
+ * @prop {'merchant_unsupported_shipping_address' | 'merchant_error'} code
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkCheckoutShippingResult
+ * @prop {boolean} ok
+ * @prop {SezzleCheckoutSdkCheckoutShippingError} [error]
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdkInit
+ * @prop {(event: MouseEvent) => void} onClick
+ * @prop {(event: CustomEvent) => void} onComplete
+ * @prop {() => void} onCancel
+ * @prop {() => void} onFailure
+ * @prop {(shippingAddress: SezzleCheckoutSdkCheckoutShippingAddress, orderUuid: string) => Promise<SezzleCheckoutSdkCheckoutShippingResult>} onCalculateAddressRelatedCosts
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutSdk
+ * @prop {(containerId: string) => void} renderSezzleButton
+ * @prop {(options: SezzleCheckoutSdkInit) => void} init
+ * @prop {(options: SezzleCheckoutSdkCheckoutPayload | SezzleCheckoutSdkCheckoutUrl) => void} startCheckout
+ */
+
+/**
+ * @typedef {object} SezzleCheckoutOptions
+ * @prop {'popup' | 'iframe' | 'redirect'} [mode='popup']
+ * @prop {string} publicKey
+ * @prop {'live' | 'sandbox'} [apiMode='live']
+ * @prop {'v2'} [apiVersion='v2']
+ */
+
+/** @typedef {new (options: SezzleCheckoutOptions) => SezzleCheckoutSdk} SezzleCheckout */
+
+const SEZZLE_BUTTON_ID = 'sezzle-smart-button-container';
+
+class SezzleDirectPayment extends Payment {
+  constructor(api, options, params, methods) {
+    super(api, options, params, methods.sezzle);
+
+    /** @type {SezzleCheckoutSdkCheckoutPayload | null} */
+    this._paymentRequest = null;
   }
 
-  if (params.card) {
-    console.warn('Please move the "config" field to the "card.config"');
+  get scripts() {
+    return ['sezzle-sdk'];
+  }
 
-    params.card.config = params.config;
+  /** @returns {SezzleCheckout} */
+  get SezzleCheckout() {
+    if (!window.Checkout) {
+      throw new LibraryNotLoadedError('Sezzle');
+    }
+
+    return window.Checkout;
   }
 
-  if (params.ideal) {
-    console.warn('Please move the "config" field to the "ideal.config"');
+  /** @returns {SezzleCheckoutSdk} */
+  get SezzleSdk() {
+    if (!this._sezzleSdk) {
+      this._sezzleSdk = new this.SezzleCheckout({
+        mode: 'popup',
+        publicKey: this.method.public_key,
+        apiMode: isLiveMode(this.method.mode) ? 'live' : 'sandbox',
+        apiVersion: 'v2',
+      });
 
-    params.ideal.config = params.config;
+      if (!this._sezzleSdk) {
+        throw new LibraryNotLoadedError('Sezzle sdk client');
+      }
+    }
+
+    return this._sezzleSdk;
   }
 
-  delete params.config;
-}
+  /**
+   * @param {Cart} cart
+   * @returns {SezzleCheckoutSdkCheckoutPayload}
+   */
+  _createPaymentRequest(cart) {
+    const {
+      settings: { name },
+    } = cart;
 
-function adjustElementId(methodParams) {
-  if (methodParams.cardNumber) {
-    adjustElementId(methodParams.cardNumber);
+    const shipmentDelivery = Boolean(cart.shipment_delivery);
+    const cartCurrency = getCartCurrency(cart);
+
+    return {
+      checkout_payload: {
+        express_checkout_type: shipmentDelivery ? 'multi-step' : 'no-shipping',
+        order: {
+          intent: 'AUTH',
+          reference_id: cart.checkout_id,
+          description: `${name} #${cart.number}`,
+          requires_shipping_info: shipmentDelivery,
+          items: getItems(cart),
+          discounts: getDiscounts(cart),
+          tax_amount: shipmentDelivery
+            ? undefined
+            : getAmountInCents(cartCurrency, cart.tax_total),
+          order_amount: getAmountInCents(cartCurrency, cart.capture_total),
+        },
+      },
+    };
   }
 
-  if (methodParams.cardExpiry) {
-    adjustElementId(methodParams.cardExpiry);
+  _createButton() {
+    const { style = {} } = this.params;
+
+    if (!style.templateText) {
+      style.templateText = '%%logo%%';
+    }
+
+    if (!style.borderType) {
+      style.borderType = 'square';
+    }
+
+    if (!style.width) {
+      style.width = '100%';
+    }
+
+    if (!style.height) {
+      style.height = '45px';
+    }
+
+    const button = document.createElement('div');
+
+    for (const attrId of Object.keys(style)) {
+      button.setAttribute(attrId, style[attrId]);
+    }
+
+    button.setAttribute('id', SEZZLE_BUTTON_ID);
+    button.style.textAlign = 'center';
+
+    return button;
   }
 
-  if (methodParams.cardCvc) {
-    adjustElementId(methodParams.cardCvc);
+  _initSezzleSdk() {
+    let shippingServices = [];
+
+    this.SezzleSdk.init({
+      onClick: (event) => {
+        event.preventDefault();
+
+        this.SezzleSdk.startCheckout(this._paymentRequest);
+      },
+      onComplete: async (event) => {
+        try {
+          const { order_uuid } = event.data;
+
+          const details = await this.authorizeGateway({
+            gateway: 'sezzle',
+            params: {
+              action: 'details',
+              order_uuid,
+            },
+          });
+
+          let shippingService = null;
+
+          if (details.service_name) {
+            shippingService =
+              shippingServices.find(
+                (service) => service.name === details.service_name,
+              )?.id ?? null;
+          }
+
+          await this.updateCart({
+            account: details.account,
+            shipping: {
+              ...details.shipping,
+              service: shippingService,
+            },
+            billing: {
+              method: 'sezzle',
+              account_card_id: null,
+              card: null,
+              sezzle: { order_uuid },
+              ...details.billing,
+            },
+          });
+
+          this.onSuccess();
+        } catch (err) {
+          this.onError(err);
+        }
+      },
+      onCancel(_event) {},
+      onFailure: (event) => {
+        this.onError(event.data);
+      },
+      onCalculateAddressRelatedCosts: async (address, orderUuid) => {
+        const cart = await this.updateCart({
+          shipping: convertToSwellAddress(address),
+        });
+
+        if (!cart.shipment_rating?.services?.length) {
+          return {
+            ok: false,
+            error: { code: 'merchant_unsupported_shipping_address' },
+          };
+        }
+
+        shippingServices = cart.shipment_rating.services;
+
+        const result = await this.authorizeGateway({
+          gateway: 'sezzle',
+          params: {
+            action: 'shipping',
+            order_uuid: orderUuid,
+            currency_code: cart.currency,
+            address_uuid: address.uuid,
+            shipping_options: cart.shipment_rating.services.map((service) => ({
+              name: service.name,
+              description: service.description,
+              shipping_amount_in_cents: amountInCents(
+                cart.currency,
+                service.price || 0,
+              ),
+              tax_amount_in_cents: amountInCents(
+                cart.currency,
+                cart.tax_total || 0,
+              ),
+              final_order_amount_in_cents: amountInCents(
+                cart.currency,
+                (cart.sub_total || 0) +
+                  (cart.tax_total || 0) +
+                  (service.price || 0),
+              ),
+            })),
+          },
+        });
+
+        if (result?.error) {
+          console.error(
+            '[Sezzle] Update checkout by order error:',
+            result.error,
+          );
+
+          return {
+            ok: false,
+            error: { code: 'merchant_error' },
+          };
+        }
+
+        return { ok: true };
+      },
+    });
   }
 
-  if (!methodParams.elementId) {
-    return;
+  /**
+   * Creates the Sezzle button element
+   *
+   * @param {Cart} cart
+   */
+  async createElements(cart) {
+    const { elementId = 'sezzle-button' } = this.params;
+
+    this.setElementContainer(elementId);
+    await this.loadScripts(this.scripts);
+
+    this._paymentRequest = this._createPaymentRequest(cart);
+
+    this.element = this._createButton();
   }
 
-  if (methodParams.elementId.startsWith('#')) {
-    console.warn(
-      `Please remove the "#" sign from the "${methodParams.elementId}" element ID`,
-    );
+  /**
+   * Mounts the Sezzle button to the DOM
+   */
+  mountElements() {
+    const { classes = {} } = this.params;
+    const container = this.elementContainer;
 
-    methodParams.elementId = methodParams.elementId.substring(1);
+    container.appendChild(this.element);
+
+    this.SezzleSdk.renderSezzleButton(SEZZLE_BUTTON_ID);
+
+    if (classes.base) {
+      container.classList.add(classes.base);
+    }
+
+    this._initSezzleSdk();
   }
 }
 
-function adjustParams(_params) {
-  const params = { ..._params };
+/**
+ * @param {Cart} cart
+ * @returns {string}
+ */
+function getCartCurrency(cart) {
+  const {
+    settings: { currency },
+  } = cart;
 
-  adjustConfig(params);
+  return cart.currency || currency || 'USD';
+}
 
-  return params;
+/**
+ * @param {string} currency
+ * @param {number} amount
+ * @returns {SezzleCheckoutSdkCheckoutPayloadOrderAmount}
+ */
+function getAmountInCents(currency, amount) {
+  return {
+    amount_in_cents: amountInCents(currency, amount),
+    currency,
+  };
 }
 
-function adjustMethodParams(_methodParams) {
-  const methodParams = { ..._methodParams };
+/**
+ * @param {Cart} cart
+ * @returns {SezzleCheckoutSdkCheckoutPayloadOrderItem[]}
+ */
+function getItems(cart) {
+  const currency = getCartCurrency(cart);
+
+  /** @type {SezzleCheckoutSdkCheckoutPayloadOrderItem[]} */
+  const items = cart.items.map((item, index) => ({
+    name: item.product?.name || `Product ${index + 1}`,
+    sku: item.product?.sku || `Product SKU ${index + 1}`,
+    quantity: item.quantity || 1,
+    price: getAmountInCents(currency, item.price || 0),
+  }));
 
-  adjustElementId(methodParams);
+  return items;
+}
 
-  return methodParams;
+/**
+ * @param {Cart} cart
+ * @returns {SezzleCheckoutSdkCheckoutPayloadOrderDiscount[]}
+ */
+function getDiscounts(cart) {
+  const currency = getCartCurrency(cart);
+
+  return (cart.discounts || []).map((discount) => ({
+    name: getDiscountLabel(discount, cart),
+    amount: getAmountInCents(currency, discount.amount || 0),
+  }));
+}
+
+/**
+ * @param {SezzleCheckoutSdkCheckoutShippingAddress} address
+ * @returns {Address}
+ */
+function convertToSwellAddress(address) {
+  return {
+    name: address.name || null,
+    address1: address.street || null,
+    address2: address.street2 || null,
+    city: address.city || null,
+    state: address.state || null,
+    zip: address.postal_code || null,
+    country: address.country_code || null,
+    phone: address.phone || null,
+  };
+}
+
+/**
+ * @param {string} currency
+ * @param {number} amount
+ * @returns {number}
+ */
+function amountInCents(currency, amount) {
+  return Math.round(amount * 100);
 }
 
 class PaymentController {
@@ -4623,6 +5074,9 @@ class PaymentController {
     return response;
   }
 
+  /**
+   * @returns {Promise<Payment[]>}
+   */
   async _createPaymentInstances() {
     const paymentMethods = await this._getPaymentMethods();
     const params = adjustParams(this.params);
@@ -4668,6 +5122,12 @@ class PaymentController {
     }, []);
   }
 
+  /**
+   * @param {Payment[]} paymentInstances
+   * @param {string} action
+   * @param  {...unknown} args
+   * @returns {Promise<Payment[]>}
+   */
   async _performPaymentAction(paymentInstances, action, ...args) {
     const actions = paymentInstances.reduce((acc, instance) => {
       const paymentAction = instance[action];
@@ -4688,9 +5148,7 @@ class PaymentController {
         await resultPromise;
         nextPaymentInstances.push(instance);
       } catch (error) {
-        const onPaymentError = instance.onError.bind(instance);
-
-        onPaymentError(error);
+        instance.onError(error);
       }
     }
 
@@ -4717,6 +5175,8 @@ class PaymentController {
         return this._getApplePaymentClass(gateway);
       case 'amazon':
         return this._getAmazonPaymentClass(gateway);
+      case 'sezzle':
+        return this._getSezzlePaymentClass(gateway);
       default:
         return null;
     }
@@ -4810,6 +5270,13 @@ class PaymentController {
         return AmazonDirectPayment;
     }
   }
+
+  _getSezzlePaymentClass(gateway) {
+    switch (gateway) {
+      default:
+        return SezzleDirectPayment;
+    }
+  }
 }
 
 export { PaymentController as default };