@fat-zebra/sdk 1.5.5-beta.0 → 1.5.5

package/dist/main.d.ts

@@ -1,7 +1,6 @@
 import { Customer, PaymentIntent, PaymentMethod, PublicEvent } from './shared/types';
 import { HppLoadParams } from './hpp';
 import { ChallengeWindowSize } from './sca/types';
-import { ApplePayParams } from './applepay/types';
 import { HppClickToPayParams } from './click_to_pay/types';
 export interface FZConfig {
     username: string;
@@ -32,7 +31,6 @@ export default class FatZebra {
     cardDidTokenize(headless: HTMLIFrameElement, callback: (data: any) => void): void;
     verifyCard(params: VerifyCardParams): Promise<void>;
     renderPaymentsPage(params: HppLoadParams): void;
-    renderApplePayButton(params: ApplePayParams): void;
     renderClickToPay(params: HppClickToPayParams): void;
     checkout(): void;
     on(event: PublicEvent, callback: (e: any) => void): void;

package/dist/main.js

@@ -11,14 +11,12 @@ import Sca from './sca';
 import { PostMessageClient, } from './shared/post-message-client';
 import { BridgeEvent, PaymentMethodType, PublicEvent, } from './shared/types';
 import { LocalStorageAccessTokenKey } from './shared/constants';
-import { emit, off, on, onOnce } from './shared/event-manager';
+import { emit, on, off, onOnce } from './shared/event-manager';
 import * as bridge from './shared/bridge-client';
-import { toHumanizedErrors, validateClickToPayLoadParams, validateHppLoadParams, validateVerifyCardParams, } from './validation';
+import { validateHppLoadParams, validateVerifyCardParams, toHumanizedErrors, validateClickToPayLoadParams, } from './validation';
 import GatewayClient from './shared/api-gateway-client';
 import { Hpp } from './hpp';
 import ClickToPay from './click_to_pay';
-import { validateApplePayLoadParams } from "./validation/validators/apple-pay-load-params-button-validator";
-import { ApplePay } from "./applepay";
 export default class FatZebra {
     constructor(config) {
         this.fzConfig = config;
@@ -122,26 +120,6 @@ export default class FatZebra {
         });
         window.HPP.load(params);
     }
-    renderApplePayButton(params) {
-        const valid = validateApplePayLoadParams(params);
-        if (!valid) {
-            emit(PublicEvent.VALIDATION_ERROR, {
-                errors: toHumanizedErrors(validateApplePayLoadParams.errors),
-                data: null
-            });
-            return;
-        }
-        window.ApplePayButton = new ApplePay({
-            environment: params.environment,
-            paymentIntent: params.paymentIntent,
-            username: this.fzConfig.username
-        });
-        window.ApplePayButton.load({
-            containerId: params.containerId,
-            paymentIntent: params.paymentIntent,
-            options: params.options
-        });
-    }
     renderClickToPay(params) {
         const valid = validateClickToPayLoadParams(params);
         if (!valid) {

package/dist/paypal/paypal-button.d.ts

@@ -0,0 +1,31 @@
+import { PayPalPaymentMethod } from './types';
+import { PaymentIntent } from '../shared/types';
+interface PayPal {
+    render(containerId: string): void;
+}
+interface PayPalButtonStyle {
+    [key: string]: any;
+}
+export default class PayPalButton {
+    private validationErrorRaised;
+    private _paypalButtons;
+    private paymentMethod;
+    private paymentIntent;
+    private buttonStyle;
+    private billingAgreement;
+    private client;
+    private actions;
+    constructor(paymentMethod?: PayPalPaymentMethod, paymentIntent?: PaymentIntent, billingAgreement?: boolean, buttonStyle?: PayPalButtonStyle);
+    get paypalButtons(): any;
+    get paypalActions(): any;
+    render(containerId: string): void;
+    getContainer(containerId: string): any;
+    private createButton;
+    private createOrder;
+    private approveOrder;
+    private createBillingAgreement;
+    private approveBillingAgreement;
+    private formatError;
+}
+export { PayPalButton };
+export type { PayPal, PayPalButtonStyle, };

package/dist/paypal/paypal-button.js

@@ -0,0 +1,199 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { emit } from '../shared/event-manager';
+import { PayPalIntent } from './types';
+import GatewayClient from '../shared/api-gateway-client';
+import { PublicEvent } from '../shared/types';
+import * as util from '../shared/util';
+import { LocalStorageAccessTokenKey } from '../shared/constants';
+const defaultStyle = {
+    layout: 'horizontal',
+    color: 'gold',
+    shape: 'pill',
+    label: 'paypal',
+};
+export default class PayPalButton {
+    constructor(paymentMethod, paymentIntent, billingAgreement, buttonStyle) {
+        this.paymentMethod = paymentMethod;
+        this.paymentIntent = paymentIntent;
+        this.billingAgreement = billingAgreement;
+        this.buttonStyle = buttonStyle;
+        this.client = new GatewayClient({ accessToken: window.localStorage.getItem(LocalStorageAccessTokenKey),
+            username: window.MerchantUsername,
+        });
+        this.createButton();
+    }
+    get paypalButtons() {
+        return this._paypalButtons;
+    }
+    get paypalActions() {
+        return this.actions;
+    }
+    render(containerId) {
+        let container = this.getContainer(containerId);
+        if (typeof (container) != 'undefined' && container != null) {
+            this._paypalButtons.render('#' + container.id);
+        }
+        else {
+            emit(PublicEvent.PAYPAL_ERROR, {
+                errors: [`Container with id #${containerId} does not exist.`],
+                data: null
+            });
+        }
+    }
+    getContainer(containerId) {
+        return document.getElementById(containerId);
+    }
+    createButton() {
+        let button = ({});
+        button.style = (this.buttonStyle ? this.buttonStyle : defaultStyle);
+        if (this.billingAgreement === true) {
+            button.createBillingAgreement = () => __awaiter(this, void 0, void 0, function* () {
+                return this.createBillingAgreement();
+            });
+            button.onApprove = (data, actions) => __awaiter(this, void 0, void 0, function* () {
+                emit(PublicEvent.PAYPAL_PROCESSESING, { data: {}, message: 'The request is being processed.' });
+                return this.approveBillingAgreement(data);
+            });
+            button.onCancel = (data, actions) => {
+                emit(PublicEvent.PAYPAL_CANCEL, { data: { id: data.orderID }, message: 'PayPal Billing Agreement cancelled.' });
+            };
+        }
+        else {
+            button.createOrder = () => __awaiter(this, void 0, void 0, function* () {
+                return this.createOrder();
+            });
+            button.onApprove = (data, actions) => __awaiter(this, void 0, void 0, function* () {
+                emit(PublicEvent.PAYPAL_PROCESSESING, { data: {}, message: 'The request is being processed.' });
+                return this.approveOrder(data);
+            });
+            button.onCancel = (data, actions) => {
+                emit(PublicEvent.PAYPAL_CANCEL, { data: { id: data.orderID }, message: 'PayPal Order cancelled.' });
+            };
+        }
+        button.onError = (error) => {
+            // This flag is used to prevent emitting general error from PayPal
+            // if an error has already been raised and emitted.
+            if (this.validationErrorRaised === false) {
+                emit(PublicEvent.PAYPAL_ERROR, {
+                    errors: ['PayPal Checkout failed.'],
+                    data: null
+                });
+            }
+        };
+        this._paypalButtons = window.paypal.Buttons(button);
+    }
+    createOrder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.validationErrorRaised = false;
+                let payload = util.toObjectWithSnakeCaseKeys(this.paymentMethod);
+                payload.payment_intent = this.paymentIntent;
+                const response = (yield this.client.createPayPalOrder({
+                    order: payload
+                })).data;
+                return response.id;
+            }
+            catch (error) {
+                this.validationErrorRaised = true;
+                emit(PublicEvent.PAYPAL_ERROR, {
+                    errors: this.formatError(error),
+                    data: null
+                });
+                return null;
+            }
+        });
+    }
+    approveOrder(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.validationErrorRaised = false;
+                let response = undefined;
+                if (this.paymentMethod.intent.toUpperCase() === PayPalIntent.CAPTURE) {
+                    response = (yield this.client.capturePayPalOrder({
+                        id: data.orderID
+                    })).data;
+                }
+                else if (this.paymentMethod.intent.toUpperCase() === PayPalIntent.AUTHORIZE) {
+                    response = (yield this.client.authorizePayPalOrder({
+                        id: data.orderID
+                    })).data;
+                }
+                emit(PublicEvent.PAYPAL_SUCCESS, {
+                    data: util.toObjectWithCamelCaseKeys(response),
+                    message: 'PayPal order approved.'
+                });
+                return;
+            }
+            catch (error) {
+                this.validationErrorRaised = true;
+                emit(PublicEvent.PAYPAL_ERROR, {
+                    errors: this.formatError(error),
+                    data: null
+                });
+                return;
+            }
+        });
+    }
+    createBillingAgreement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.validationErrorRaised = false;
+                let payload = util.toObjectWithSnakeCaseKeys(this.paymentMethod);
+                delete payload.billing_agreement;
+                let response = (yield this.client.createPayPalBillingAgreement({
+                    billing: payload
+                })).data;
+                return response.token_id;
+            }
+            catch (error) {
+                this.validationErrorRaised = true;
+                emit(PublicEvent.PAYPAL_ERROR, {
+                    errors: this.formatError(error),
+                    data: null
+                });
+                return;
+            }
+        });
+    }
+    approveBillingAgreement(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.validationErrorRaised = false;
+                let response = (yield this.client.approvePayPalBillingAgreement({
+                    id: data.billingToken
+                })).data;
+                emit(PublicEvent.PAYPAL_SUCCESS, {
+                    data: util.toObjectWithCamelCaseKeys(response),
+                    message: 'PayPal Billing Agreement created.'
+                });
+                return;
+            }
+            catch (error) {
+                this.validationErrorRaised = true;
+                emit(PublicEvent.PAYPAL_ERROR, {
+                    errors: this.formatError(error),
+                    data: null
+                });
+                return;
+            }
+        });
+    }
+    formatError(error) {
+        var _a, _b;
+        var message = [(_b = (_a = error === null || error === void 0 ? void 0 : error.request) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.errors].flat();
+        if (typeof message[0] === 'undefined')
+            message = [error === null || error === void 0 ? void 0 : error.message].flat();
+        if (typeof message[0] === 'undefined')
+            message = ['Unknown error'];
+        return message;
+    }
+}
+export { PayPalButton };

package/dist/paypal/paypal-checkout.d.ts

@@ -0,0 +1,21 @@
+import { PayPalButton } from './paypal-button';
+import { PayPalConfig } from './types';
+export default class PayPalCheckout {
+    private paypalButton;
+    private validationErrors;
+    private intent;
+    private currency;
+    private payment;
+    private billingAgreement;
+    private containerId;
+    private buttonStyle;
+    constructor(config: PayPalConfig);
+    get paypal(): PayPalButton;
+    set paypal(paypal: PayPalButton);
+    load(): Promise<any>;
+    render(): void;
+    private validatePayPalSetup;
+    private validatePayPalRequest;
+    private errors;
+}
+export { PayPalCheckout };

package/dist/paypal/paypal-checkout.js

@@ -0,0 +1,100 @@
+// This is the implementation of PayPal Checkout
+//
+// https://developer.paypal.com/docs/checkout/
+import { emit } from '../shared/event-manager';
+import { PaymentMethodType, PublicEvent } from '../shared/types';
+import { PayPalButton, } from './paypal-button';
+import { validatePayPalSetup, validatePayPalRequest, } from './validation';
+export default class PayPalCheckout {
+    constructor(config) {
+        var _a, _b, _c, _d, _e;
+        if (!this.validatePayPalSetup(config)) {
+            emit(PublicEvent.PAYPAL_ERROR, {
+                errors: this.errors(),
+                data: null
+            });
+            return;
+        }
+        this.billingAgreement = (((_b = (_a = config === null || config === void 0 ? void 0 : config.payment) === null || _a === void 0 ? void 0 : _a.paymentMethod) === null || _b === void 0 ? void 0 : _b.type) === PaymentMethodType.PAYPAL_BILLING);
+        this.payment = config === null || config === void 0 ? void 0 : config.payment;
+        this.intent = (_e = (_d = (_c = config === null || config === void 0 ? void 0 : config.payment) === null || _c === void 0 ? void 0 : _c.paymentMethod) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.intent;
+        this.currency = config === null || config === void 0 ? void 0 : config.currency;
+        this.containerId = config === null || config === void 0 ? void 0 : config.containerId;
+        this.buttonStyle = config === null || config === void 0 ? void 0 : config.style;
+        if (!this.validatePayPalRequest()) {
+            emit(PublicEvent.PAYPAL_ERROR, {
+                errors: this.errors(),
+                data: null
+            });
+            return;
+        }
+    }
+    get paypal() {
+        return this.paypalButton;
+    }
+    set paypal(paypal) {
+        this.paypalButton = paypal;
+    }
+    load() {
+        if (this.errors()) {
+            return;
+        }
+        if (this.intent && !this.billingAgreement) {
+            let data = this.payment.paymentMethod.data;
+            data.intent = this.intent.toUpperCase();
+        }
+        let self = this;
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.type = 'text/javascript';
+            let source = process.env.PAYPAL_SDK_URL + '&client-id=' + process.env.PAYPAL_CLIENT_ID + '&debug=' + process.env.PAYPAL_DEBUG;
+            if (this.currency)
+                source += '&currency=' + this.currency;
+            if (this.intent && !this.billingAgreement)
+                source += '&intent=' + this.intent;
+            if (this.billingAgreement === true)
+                source += '&vault=true';
+            script.setAttribute('data-partner-attribution-id', process.env.PAYPAL_PARTNER_ID);
+            script.src = source;
+            script.async = true;
+            document.body.appendChild(script);
+            script.onload = () => {
+                self.paypalButton = new PayPalButton(self.payment.paymentMethod.data, self.payment.paymentIntent, self.billingAgreement, self.buttonStyle);
+                resolve(null);
+            };
+            script.onerror = () => {
+                reject(['Loading PayPal failed']);
+            };
+        });
+    }
+    render() {
+        if (this.errors()) {
+            return;
+        }
+        this.paypalButton.render(this.containerId);
+    }
+    validatePayPalSetup(config) {
+        const validations = validatePayPalSetup(config);
+        this.validationErrors = null;
+        if (!validations.valid) {
+            this.validationErrors = validations.errors;
+            return false;
+        }
+        return true;
+    }
+    validatePayPalRequest() {
+        const validations = validatePayPalRequest(this.payment, this.billingAgreement);
+        this.validationErrors = null;
+        if (!validations.valid) {
+            this.validationErrors = validations.errors;
+            return false;
+        }
+        return true;
+    }
+    errors() {
+        if (this.validationErrors !== null)
+            return this.validationErrors;
+        return null;
+    }
+}
+export { PayPalCheckout };

package/dist/paypal/types.d.ts

@@ -0,0 +1,188 @@
+import { PaymentMethod, PaymentIntent } from '../shared/types';
+export interface PayPalConfig {
+    currency: string;
+    payment: PayPalOrderParams;
+    containerId: string;
+    style?: {
+        [key: string]: any;
+    };
+}
+export interface PayPalOrderParams {
+    paymentIntent?: PaymentIntent;
+    paymentMethod: PaymentMethod;
+}
+export declare enum PayPalIntent {
+    CAPTURE = "CAPTURE",
+    AUTHORIZE = "AUTHORIZE"
+}
+export type PayPalPaymentMethod = PayPalOrderRequest | PayPalBillingAgreementRequest;
+/***************** PayPal Order Object ******************/
+export interface PayPalOrderRequest {
+    intent: 'capture' | 'authorize';
+    options?: {
+        brandName?: string;
+        landingPage?: string;
+        payeePreferredPayment?: string;
+        shippingPreference?: string;
+    };
+    purchases: Purchases[];
+}
+interface Purchases {
+    description?: string;
+    softDescriptor?: string;
+    amount: Amount;
+    items?: Item[];
+    shippingAddress: {
+        name?: string;
+        method?: string;
+        address: Address;
+    };
+    payee?: {
+        emailAddress: string;
+        merchantId: string;
+    };
+}
+interface Amount {
+    itemTotal?: number;
+    shipping?: number;
+    handling?: number;
+    taxTotal?: number;
+    shippingDiscount?: number;
+    insurance?: number;
+    discount?: number;
+}
+interface Address {
+    firstName?: string;
+    lastName?: string;
+    address_1?: string;
+    address_2?: string;
+    city?: string;
+    state?: string;
+    postcode?: string;
+    country: string;
+}
+interface Item {
+    name: string;
+    description?: string;
+    sku?: string;
+    unitAmount: number;
+    tax?: number;
+    qty: string;
+    category?: string;
+}
+export interface CreatePayPalOrderRequest {
+    order: PayPalOrderRequest;
+}
+export interface PayPalOrderResponse {
+    id: string;
+    intent: PayPalIntent;
+}
+/***************** PayPal Capture Object ******************/
+export interface CapturePayPalOrderRequest {
+    id: string;
+}
+export interface CapturePayPalOrderResponse {
+    id: string;
+    intent: string;
+    reference: string;
+    paypal_reference: string;
+    invoice_id: string;
+    amount: number;
+    decimal_amount: number;
+    captured_amount: number;
+    captured: boolean;
+    successful: boolean;
+    status: string;
+    message: string;
+    currency: string;
+    transaction_id: string;
+    transaction_date: Date;
+    response_code: string;
+    paypal_fee: number;
+    seller_receivable_net_amount: number;
+    note_to_payer: string;
+    is_final_capture: boolean;
+    refunded_amount: number;
+    balance_available_for_refund: number;
+    balance_available_for_capture: number;
+    authorization: string;
+    order: string;
+}
+/***************** PayPal Authorize Object ******************/
+export interface AuthorizePayPalOrderRequest {
+    id: string;
+}
+export interface AuthorizePayPalOrderResponse {
+    id: string;
+    intent: string;
+    reference: string;
+    paypal_reference: string;
+    invoice_id: string;
+    amount: number;
+    decimal_amount: number;
+    captured_amount: number;
+    captured: boolean;
+    successful: boolean;
+    status: string;
+    message: string;
+    currency: string;
+    transaction_id: string;
+    transaction_date: Date;
+    response_code: string;
+    refunded_amount: number;
+    balance_available_for_capture: number;
+    order: string;
+}
+/***************** PayPal Billing Agreement Object ******************/
+export interface PayPalBillingAgreementRequest {
+    name?: string;
+    description?: string;
+    shippingAddress: BillingAddress;
+    merchantCustomData?: string;
+}
+export interface CreatePayPalBillingAgreementRequest {
+    billing: PayPalBillingAgreementRequest;
+}
+interface BillingAddress {
+    firstName?: string;
+    lastName?: string;
+    address_1: string;
+    address_2?: string;
+    city: string;
+    state: string;
+    postcode: string;
+    country: string;
+}
+export interface PayPalBillingAgreementResponse {
+    token_id: string;
+}
+export interface ApprovePayPalBillingAgreementRequest {
+    id: string;
+}
+export interface ApprovePayPalBillingAgreementResponse {
+    token: string;
+    name?: string;
+    description?: string;
+    state: string;
+    payer?: {
+        payer_info: {
+            email: string;
+            first_name: string;
+            last_name: string;
+            payer_id: string;
+        };
+    };
+    shipping_address?: {
+        first_name?: string;
+        last_name?: string;
+        address_1: string;
+        address_2?: string;
+        city: string;
+        state: string;
+        postcode: string;
+        country: string;
+    };
+    merchant_custom_data?: string;
+    created_at: Date;
+}
+export {};

package/dist/paypal/types.js

@@ -0,0 +1,5 @@
+export var PayPalIntent;
+(function (PayPalIntent) {
+    PayPalIntent["CAPTURE"] = "CAPTURE";
+    PayPalIntent["AUTHORIZE"] = "AUTHORIZE";
+})(PayPalIntent || (PayPalIntent = {}));

package/dist/paypal/validation.d.ts

@@ -0,0 +1,4 @@
+import { PayPalConfig, PayPalOrderParams } from './types';
+import { ValidationResult } from '../shared/types';
+export declare const validatePayPalSetup: (props: PayPalConfig) => ValidationResult;
+export declare const validatePayPalRequest: (props: PayPalOrderParams, billing?: boolean) => ValidationResult;

package/dist/paypal/validation.js

@@ -0,0 +1,65 @@
+import { PayPalIntent } from './types';
+const PaypalConfigRequiredProps = ['currency', 'containerId', 'payment'];
+const PaypalOrderRequiredProps = ['intent', 'purchases'];
+const PaypalBillingRequiredProps = ['shippingAddress'];
+export const validatePayPalSetup = (props) => {
+    let errors = [];
+    const keys = Object.keys(props);
+    for (let requiredProp of PaypalConfigRequiredProps) {
+        // @ts-ignore
+        if (!keys.includes(requiredProp) || props[requiredProp] === undefined) {
+            errors.push(`${requiredProp} is missing.`);
+        }
+    }
+    return {
+        valid: errors.length == 0,
+        errors
+    };
+};
+export const validatePayPalRequest = (props, billing) => {
+    let errors = [];
+    const keys = Object.keys(props);
+    if (!keys.includes('paymentMethod')) {
+        errors.push(`paymentMethod is missing.`);
+    }
+    if (!keys.includes('paymentIntent') && !billing) {
+        errors.push(`paymentIntent is missing.`);
+    }
+    if (props.paymentMethod) {
+        const orderKeys = Object.keys(props.paymentMethod.data);
+        if (orderKeys.includes('intent')) {
+            const intent = props.paymentMethod.data.intent.toLowerCase();
+            const intents = Object.values(PayPalIntent).map(v => v.toLowerCase());
+            if (!intents.includes(intent)) {
+                errors.push(`intent is invalid, must be one of [${intents.join(', ')}].`);
+            }
+        }
+        if (!props.paymentMethod.type) {
+            errors.push(`paymentMethod.type is missing.`);
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            valid: errors.length == 0,
+            errors
+        };
+    }
+    const paymentMethod = props.paymentMethod.data;
+    const providedKeys = Object.keys(paymentMethod);
+    let requiredProps;
+    if (billing === true) {
+        requiredProps = PaypalBillingRequiredProps;
+    }
+    else {
+        requiredProps = PaypalOrderRequiredProps;
+    }
+    for (let requiredProp of requiredProps) {
+        if (!providedKeys.includes(requiredProp)) {
+            errors.push(`${requiredProp} is missing.`);
+        }
+    }
+    return {
+        valid: errors.length == 0,
+        errors
+    };
+};

package/dist/react/index.d.ts

@@ -1,5 +1,4 @@
 import VerifyCard from "./VerifyCard";
 import VerifyExistingCard from "./VerifyExistingCard";
 import submitForm from "./submitForm";
-import ApplePayButton from "./ApplePayButton";
-export { VerifyCard, VerifyExistingCard, submitForm, ApplePayButton };
+export { VerifyCard, VerifyExistingCard, submitForm };