@fat-zebra/sdk 1.0.5 → 1.2.1

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/VerifyCard.d.ts

@@ -2,9 +2,7 @@ import React from "react";
 import * as FatZebra from "../shared/types";
 type FrameProps = {
     handlers: FatZebra.Handlers;
-    username: string;
-    accessToken: string;
-    config: FatZebra.VerificationConfig;
+    config: FatZebra.PaymentConfig;
 };
-declare const Frame: ({ username, handlers, config }: FrameProps) => React.JSX.Element;
+declare const Frame: ({ handlers, config }: FrameProps) => React.JSX.Element;
 export default Frame;

package/dist/react/VerifyCard.js

@@ -1,15 +1,15 @@
 import React from "react";
 import useFatZebra from "./useFatZebra";
-const Frame = ({ username, handlers, config }) => {
+import * as env from "../shared/env";
+const Frame = ({ handlers, config }) => {
     const bridgeRef = React.useRef(null);
     const { url } = useFatZebra({
-        username: username,
         config,
         handlers: handlers,
         bridge: bridgeRef,
     });
     return (React.createElement("div", null,
         React.createElement("iframe", { src: url, width: "100%", height: "700px", title: "verification-form" }),
-        React.createElement("iframe", { title: "bridge-form", src: "http://paynow.test:3004/sdk/bridge", width: "100%", height: "700px", ref: bridgeRef })));
+        React.createElement("iframe", { title: "bridge-form", src: env.bridgeUrl, width: "100%", height: "700px", ref: bridgeRef })));
 };
 export default Frame;

package/dist/react/url.d.ts

@@ -1,3 +1,4 @@
+import { OptionalUrlValues } from '../shared/types';
 type RequiredURLValues = {
     merchant: string;
     hash: string;
@@ -5,22 +6,6 @@ type RequiredURLValues = {
     amount: number;
     currency: string;
 };
-type VerificationURLValues = OptionalURLValues & {
-    merchant: string;
-    timestamp: string;
-    verification: string;
-};
-type OptionalURLValues = Partial<{
-    hide_card_holder: string;
-    return_path: string;
-    card_types: Array<string>;
-    surcharge_enabled: string;
-    sca_enabled: boolean;
-    css: string;
-    css_signature: string;
-    tokenize_only: boolean;
-}>;
-type UrlValues = RequiredURLValues & OptionalURLValues;
+type UrlValues = RequiredURLValues & OptionalUrlValues;
 declare const generatePaymentURL: (values: UrlValues) => string;
-declare const generateVerificationURL: (values: VerificationURLValues) => string;
-export { generatePaymentURL, generateVerificationURL };
+export { generatePaymentURL };

package/dist/react/url.js

@@ -1,4 +1,5 @@
 import { parseTemplate } from 'url-template';
+import * as env from "../shared/env";
 const generatePaymentURL = (values) => {
     const queryParts = [
         "tokenize_only",
@@ -12,7 +13,7 @@ const generatePaymentURL = (values) => {
         "surcharge_enabled",
         "sca_enabled",
     ];
-    const urlTemplate = parseTemplate(`http://paynow.test:3004/sdk/v3/{merchant}/{reference}/{currency}/{amount}/{verification}{?${queryParts.join(",")}}`);
+    const urlTemplate = parseTemplate(`${env.payNowUrl}/sdk/v3/{merchant}/{reference}/{currency}/{amount}/{verification}{?${queryParts.join(",")}}`);
     const url = urlTemplate.expand({
         merchant: values.merchant,
         reference: values.reference,
@@ -28,31 +29,4 @@ const generatePaymentURL = (values) => {
     });
     return url;
 };
-const generateVerificationURL = (values) => {
-    const queryParts = [
-        "tokenize_only",
-        "css",
-        "css_signature",
-        "iframe",
-        "postmessage",
-        "hide_card_holder",
-        "return_path",
-        "card_types",
-        "surcharge_enabled",
-        "sca_enabled",
-    ];
-    const urlTemplate = parseTemplate(`http://paynow.test:3004/sdk/v3/{merchant}/verification/{timestamp}/{verification}{?${queryParts.join(",")}}`);
-    const url = urlTemplate.expand({
-        merchant: values.merchant,
-        timestamp: values.timestamp,
-        verification: values.verification,
-        sca_enabled: values.sca_enabled,
-        css: values.css,
-        css_signature: values.css_signature,
-        iframe: true,
-        postmessage: true,
-        tokenize_only: values.tokenize_only,
-    });
-    return url;
-};
-export { generatePaymentURL, generateVerificationURL };
+export { generatePaymentURL };

package/dist/react/useFatZebra.d.ts

@@ -1,12 +1,11 @@
 /// <reference types="react" />
 import * as FatZebra from "../shared/types";
 type UseFatZebraProps = {
-    username: string;
     handlers: FatZebra.Handlers;
-    config: FatZebra.VerificationConfig;
+    config: FatZebra.PaymentConfig;
     bridge: React.MutableRefObject<HTMLIFrameElement>;
 };
-declare const useFatZebra: ({ username, config, handlers, bridge }: UseFatZebraProps) => {
+declare const useFatZebra: ({ config, handlers, bridge }: UseFatZebraProps) => {
     url: string;
 };
 export default useFatZebra;

package/dist/react/useFatZebra.js

@@ -3,11 +3,13 @@ import * as FatZebra from "../shared/types";
 import { generatePaymentURL } from "./url";
 import Sca from "../sca";
 import GatewayClient from "../shared/api-gateway-client";
-const useFatZebra = ({ username, config, handlers, bridge }) => {
-    const { options, accessToken, paymentIntent, verification } = config;
+const useFatZebra = ({ config, handlers, bridge }) => {
+    const { options, accessToken, paymentIntent, username } = config;
     const sca = useMemo(() => {
         const gatewayClient = new GatewayClient({ accessToken, username });
-        return new Sca({ gatewayClient });
+        const successCallback = handlers[FatZebra.PublicEvent.SCA_SUCCESS];
+        const failureCallback = handlers[FatZebra.PublicEvent.SCA_ERROR];
+        return new Sca({ gatewayClient, successCallback, failureCallback });
     }, [config, username]);
     const emit = (event, data) => {
         const handler = handlers[event];
@@ -60,9 +62,7 @@ const useFatZebra = ({ username, config, handlers, bridge }) => {
                 },
             });
         }
-        if (options.tokenizeOnly)
-            return;
-        if (options.enableSca) {
+        if (options.sca_enabled) {
             sca.run({ paymentIntent, bin: data.bin, cardToken: data.token });
         }
     };
@@ -101,7 +101,7 @@ const useFatZebra = ({ username, config, handlers, bridge }) => {
         };
     }, []);
     const payment = paymentIntent.payment;
-    const url = generatePaymentURL(Object.assign(Object.assign({}, options), { merchant: username, reference: payment.reference, amount: payment.amount, currency: payment.currency, hash: verification }));
+    const url = generatePaymentURL(Object.assign({ merchant: username, reference: payment.reference, amount: payment.amount, currency: payment.currency, hash: paymentIntent.verification }, options));
     return { url };
 };
 export default useFatZebra;

package/dist/sca/cardinal.d.ts

@@ -25,5 +25,5 @@ export default class CardinalManager {
     processBin(bin: string): Promise<any>;
     continue(acsUrl: string, pareq: string, transactionId: string): void;
 }
-export { CardinalManager };
+export { CardinalManager, };
 export type { PaymentValidatedDTO };

package/dist/sca/cardinal.js

@@ -67,4 +67,4 @@ export default class CardinalManager {
         });
     }
 }
-export { CardinalManager };
+export { CardinalManager, };

package/dist/sca/index.d.ts

@@ -1,5 +1,5 @@
 import * as t from './types';
-import { Customer, CustomerSnakeCase, PaymentIntent } from '../shared/types';
+import { Customer, CustomerSnakeCase, PaymentIntent, PublicEvent } from '../shared/types';
 import { CardinalManager } from './cardinal';
 import GatewayClient from '../shared/api-gateway-client';
 export interface ScaRunProps {
@@ -11,10 +11,11 @@ export interface ScaRunProps {
 }
 export interface ScaConfig {
     gatewayClient: GatewayClient;
+    successCallback?: (event: PublicEvent.SCA_SUCCESS, detail: any) => void;
+    failureCallback?: (event: PublicEvent.SCA_ERROR, detail: any) => void;
 }
 declare class Sca {
     private _cardinal;
-    private _eventEmitTarget;
     private enrollmentResult;
     private paymentIntent;
     private bin;
@@ -23,12 +24,14 @@ declare class Sca {
     private challengeWindowSize;
     private sessionId;
     private gatewayClient;
-    constructor({ gatewayClient }: ScaConfig);
+    private successCallback;
+    private failureCallback;
+    constructor({ gatewayClient, successCallback, failureCallback }: ScaConfig);
     loadScript(): void;
     get cardinal(): CardinalManager;
     set cardinal(cardinal: CardinalManager);
-    get eventEmitTarget(): HTMLDivElement | Window;
-    set eventEmitTarget(target: HTMLDivElement | Window);
+    reportFailure(message: string): void;
+    reportSuccess(message: string, data: any): void;
     run(config: ScaRunProps): Promise<void>;
     createCardinalJWT(): Promise<string>;
     check3DSEnrollment(): Promise<void>;