@fat-zebra/sdk 1.0.6 → 1.2.2

package/dist/index.d.ts

@@ -1,2 +1,5 @@
-import { Payment, PaymentIntent, VerificationConfig, Handlers, PublicEvent } from "./shared/types";
-export { type Payment, type PaymentIntent, type VerificationConfig, type Handlers, PublicEvent, };
+import "ts-polyfill";
+import "custom-event-polyfill";
+import { type PaymentIntent, type Payment, PublicEvent, type PaymentConfig, type Handlers } from "./shared/types";
+export type { PaymentIntent, Payment, PaymentConfig, Handlers };
+export { PublicEvent };

package/dist/index.js

@@ -1,2 +1,8 @@
+import "ts-polyfill";
+import "custom-event-polyfill";
+import { FatZebra } from "./main";
 import { PublicEvent } from "./shared/types";
-export { PublicEvent, };
+export { PublicEvent };
+if (typeof window !== "undefined") {
+    window.FatZebra = FatZebra;
+}

package/dist/main.d.ts

@@ -0,0 +1,38 @@
+import { Customer, PaymentIntent, PaymentMethod, PublicEvent } from './shared/types';
+import { HppLoadParams } from './hpp';
+import { PayPalConfig } from './paypal/types';
+import { ChallengeWindowSize } from './sca/types';
+export interface FZConfig {
+    username: string;
+    test?: boolean;
+}
+interface Card {
+    number: string;
+    holder: string;
+    expiryMonth: string;
+    expiryYear: string;
+    cvv: string;
+}
+interface VerifyCardParams {
+    customer: Customer;
+    paymentIntent: PaymentIntent;
+    paymentMethod: PaymentMethod;
+    options?: VerifyCardOptions;
+}
+interface VerifyCardOptions {
+    challengeWindowSize?: ChallengeWindowSize;
+}
+export default class FatZebra {
+    private sca;
+    private fzConfig;
+    private gatewayClient;
+    constructor(config: FZConfig);
+    tokenizeCard(card: Card, headless: HTMLIFrameElement): void;
+    cardDidTokenize(headless: HTMLIFrameElement, callback: (data: any) => void): void;
+    verifyCard(params: VerifyCardParams): Promise<void>;
+    renderPaymentsPage(params: HppLoadParams): void;
+    checkout(): void;
+    setupPayPal(config: PayPalConfig): void;
+    on(event: PublicEvent, callback: (e: any) => void): void;
+}
+export { type HppLoadParams, FatZebra, };

package/dist/main.js

@@ -0,0 +1,148 @@
+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 Sca from './sca';
+import { PostMessageClient, } from './shared/post-message-client';
+import { BridgeEvent, PaymentMethodType, PublicEvent, } from './shared/types';
+import { LocalStorageAccessTokenKey } from './shared/constants';
+import { emit, on } from './shared/event-manager';
+import * as bridge from './shared/bridge-client';
+import { validateHppLoadParams, validateVerifyCardParams, toHumanizedErrors, } from './validation';
+import GatewayClient from './shared/api-gateway-client';
+import { Hpp } from './hpp';
+import { PayPalCheckout } from './paypal/paypal-checkout';
+export default class FatZebra {
+    constructor(config) {
+        this.fzConfig = config;
+        window.MerchantUsername = config.username;
+        this.gatewayClient = new GatewayClient({
+            accessToken: window.localStorage.getItem(LocalStorageAccessTokenKey),
+            username: config.username,
+        });
+        this.sca = new Sca({
+            gatewayClient: this.gatewayClient,
+        });
+        this.sca.loadScript();
+    }
+    tokenizeCard(card, headless) {
+        const channel = 'sca';
+        headless.onload = () => {
+            const message = {
+                channel,
+                subject: BridgeEvent.TOKENIZE_CARD_REQUEST,
+                data: {
+                    access_token: window.localStorage.getItem(LocalStorageAccessTokenKey),
+                    card_holder: card.holder,
+                    card_number: card.number,
+                    card_expiry: `${card.expiryMonth}/${card.expiryYear}`,
+                    cvv: card.cvv,
+                }
+            };
+            headless.contentWindow.postMessage(message, '*');
+        };
+    }
+    cardDidTokenize(headless, callback) {
+        const channel = 'sca';
+        const postMessageClient = new PostMessageClient({
+            channel,
+            target: headless
+        });
+        const handlers = {};
+        handlers[BridgeEvent.TOKENIZE_CARD_RESPONSE] = (data) => {
+            callback(data);
+        };
+        postMessageClient.setEventListeners(handlers);
+    }
+    verifyCard(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const valid = validateVerifyCardParams(params);
+            if (!valid) {
+                emit(PublicEvent.VALIDATION_ERROR, {
+                    errors: toHumanizedErrors(validateVerifyCardParams.errors),
+                    data: null
+                });
+                return;
+            }
+            switch (params.paymentMethod.type) {
+                case PaymentMethodType.CARD:
+                    const headless = bridge.load(process.env.PAYNOW_BRIDGE_URL);
+                    const card = params.paymentMethod.data;
+                    this.cardDidTokenize(headless, (data) => __awaiter(this, void 0, void 0, function* () {
+                        var _b;
+                        const bin = card.number.substr(0, 6);
+                        this.sca.run({
+                            cardToken: data.token,
+                            customer: params.customer,
+                            paymentIntent: params.paymentIntent,
+                            bin,
+                            challengeWindowSize: (_b = params.options) === null || _b === void 0 ? void 0 : _b.challengeWindowSize,
+                        });
+                    }));
+                    this.tokenizeCard(card, headless);
+                    break;
+                case PaymentMethodType.CARD_ON_FILE:
+                    const cardToken = params.paymentMethod.data.token;
+                    const bin = (yield this.gatewayClient.getCard({ card_token: cardToken })).data.bin;
+                    this.sca.run({
+                        cardToken,
+                        customer: params.customer,
+                        paymentIntent: params.paymentIntent,
+                        bin,
+                        challengeWindowSize: (_a = params.options) === null || _a === void 0 ? void 0 : _a.challengeWindowSize,
+                    });
+                    break;
+            }
+        });
+    }
+    renderPaymentsPage(params) {
+        const valid = validateHppLoadParams(params);
+        if (!valid) {
+            emit(PublicEvent.VALIDATION_ERROR, {
+                errors: toHumanizedErrors(validateHppLoadParams.errors),
+                data: null
+            });
+            return;
+        }
+        window.HPP = new Hpp({
+            version: params.version,
+            paymentIntent: params.paymentIntent,
+            customer: params.customer,
+            username: this.fzConfig.username,
+            sca: this.sca,
+            test: this.fzConfig.test,
+        });
+        window.HPP.load(params);
+    }
+    checkout() {
+        window.HPP.purchase();
+    }
+    setupPayPal(config) {
+        const paypalCheckout = new PayPalCheckout({
+            currency: config.currency,
+            payment: config.payment,
+            containerId: config.containerId,
+            style: config.style
+        });
+        paypalCheckout.load()
+            .then(function () {
+            paypalCheckout.render();
+        })
+            .catch(function (error) {
+            emit(PublicEvent.PAYPAL_ERROR, {
+                errors: [error].flat(),
+                data: null
+            });
+        });
+    }
+    on(event, callback) {
+        on(event, callback);
+    }
+}
+export { FatZebra, };

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 };