@fat-zebra/sdk 1.0.6 → 1.2.2

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,10 +1,9 @@
 import React from "react";
 import useFatZebra from "./useFatZebra";
 import * as env from "../shared/env";
-const Frame = ({ username, handlers, config }) => {
+const Frame = ({ handlers, config }) => {
     const bridgeRef = React.useRef(null);
     const { url } = useFatZebra({
-        username: username,
         config,
         handlers: handlers,
         bridge: bridgeRef,

package/dist/react/url.d.ts

@@ -1,3 +1,4 @@
+import { OptionalUrlValues } from '../shared/types';
 type RequiredURLValues = {
     merchant: string;
     hash: string;
@@ -5,16 +6,6 @@ type RequiredURLValues = {
     amount: number;
     currency: 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;
 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>;

package/dist/sca/index.js

@@ -13,30 +13,22 @@ import { PublicEvent, } from '../shared/types';
 import { CardinalManager, } from './cardinal';
 import { emit, } from '../shared/event-manager';
 import { toFzSli } from './eci-mappings';
-import * as env from "../shared/env";
 class Sca {
-    constructor({ gatewayClient }) {
-        this._eventEmitTarget = window;
+    constructor({ gatewayClient, successCallback, failureCallback }) {
         this.sessionId = null;
         this.gatewayClient = gatewayClient;
-        this.loadScript();
+        this.successCallback = successCallback || emit;
+        this.failureCallback = failureCallback || emit;
     }
     loadScript() {
-        if (!document.getElementById("songbird-script")) {
-            console.log(env);
-            const script = document.createElement('script');
-            script.type = 'text/javascript';
-            script.id = "songbird-script";
-            script.src = env.songbirdUrl;
-            script.async = true;
-            script.onload = () => {
-                this._cardinal = new CardinalManager();
-            };
-            document.body.appendChild(script);
-        }
-        else {
+        const script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = process.env.SONGBIRD_URL;
+        script.async = true;
+        script.onload = () => {
             this._cardinal = new CardinalManager();
-        }
+        };
+        document.body.appendChild(script);
     }
     get cardinal() {
         return this._cardinal;
@@ -44,12 +36,13 @@ class Sca {
     set cardinal(cardinal) {
         this._cardinal = cardinal;
     }
-    get eventEmitTarget() {
-        return this._eventEmitTarget;
+    reportFailure(message) {
+        this.failureCallback(PublicEvent.SCA_ERROR, { errors: [message] });
+        console.log(message);
     }
-    // Specify the DOM element to which the SCA results are outputted.
-    set eventEmitTarget(target) {
-        this._eventEmitTarget = target;
+    reportSuccess(message, data) {
+        this.successCallback(PublicEvent.SCA_SUCCESS, { data, message });
+        console.log(message);
     }
     run(config) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -65,12 +58,7 @@ class Sca {
                 cardinalJwt = yield this.createCardinalJWT();
             }
             catch (error) {
-                const message = 'FatZebra.3DS: JWT creation failed.';
-                emit(PublicEvent.SCA_ERROR, {
-                    errors: [message],
-                    data: null
-                });
-                console.log(message);
+                this.reportFailure('FatZebra.3DS: JWT creation failed.');
                 return;
             }
             // Init cardinal
@@ -81,24 +69,14 @@ class Sca {
                 // Register handler. Called after OTP is entered on challenge prompt.
                 this._cardinal.onPaymentValidated((data, error) => __awaiter(this, void 0, void 0, function* () {
                     if (typeof error == 'string') {
-                        const message = `FatZebra.3DS: Validation failed. ${error}.`;
-                        emit(PublicEvent.SCA_ERROR, {
-                            errors: [message],
-                            data: null,
-                        });
-                        console.log(message);
+                        this.reportFailure(`FatZebra.3DS: Validation failed. ${error}.`);
                         return;
                     }
                     const decodeSCASessionResponse = (yield this.gatewayClient.decodeSCASession({
                         token: data.jwt
                     })).data;
                     if (data.processorTransactionId !== decodeSCASessionResponse.processor_transaction_id) {
-                        const message = 'FatZebra.3DS: Validation failed. Invalid process transaction id.';
-                        emit(PublicEvent.SCA_ERROR, {
-                            errors: [message],
-                            data: null
-                        });
-                        console.log(message);
+                        this.reportFailure("FatZebra.3DS: Validation failed. Invalid process transaction id.");
                     }
                     let validateSCAResponse;
                     try {
@@ -113,33 +91,16 @@ class Sca {
                         validateSCAResponse = (yield this.gatewayClient.validateSCA(requestParams)).data;
                     }
                     catch (errorResponse) {
-                        const message = 'FatZebra.3DS: Validation failed. Server error.';
-                        emit(PublicEvent.SCA_ERROR, {
-                            errors: [message],
-                            data: null,
-                        });
-                        console.log(message);
+                        this.reportFailure('FatZebra.3DS: Validation failed. Server error.');
                         return;
                     }
                     const threedsData = threedsResponseData(validateSCAResponse);
                     const scenario = getValidationResult(validateSCAResponse);
                     if (scenario.outcome.success) {
-                        const message = `FatZebra.3DS: 3DS success - ${scenario.description}.`;
-                        emit(PublicEvent.SCA_SUCCESS, {
-                            message,
-                            data: threedsData,
-                        });
-                        console.log(message);
+                        this.reportSuccess(`FatZebra.3DS: 3DS success - ${scenario.description}.`, threedsData);
                     }
                     else {
-                        const message = `FatZebra.3DS: 3DS error - ${scenario.description}`;
-                        emit(PublicEvent.SCA_ERROR, {
-                            errors: [message],
-                            data: {
-                                errorCode: scenario.outcome.errorCode
-                            },
-                        });
-                        console.log(message);
+                        this.reportFailure(`FatZebra.3DS: 3DS error - ${scenario.description} - ${scenario.outcome.errorCode}`);
                     }
                 }));
             }
@@ -148,24 +109,14 @@ class Sca {
                 yield this._cardinal.processBin(this.bin);
             }
             catch (err) {
-                const message = 'FatZebra.3DS: BIN verification failed.';
-                emit(PublicEvent.SCA_ERROR, {
-                    errors: [message],
-                    data: null
-                });
-                console.log(message);
+                this.reportFailure('FatZebra.3DS: BIN verification failed.');
                 return;
             }
             try {
                 yield this.check3DSEnrollment();
             }
             catch (err) {
-                const message = 'FatZebra.3DS: Enrollment failed. Server error.';
-                emit(PublicEvent.SCA_ERROR, {
-                    errors: [message],
-                    data: null
-                });
-                console.log(message);
+                this.reportFailure('FatZebra.3DS: Enrollment failed. Server error.');
                 return;
             }
             this.handleEnrollmentResult(this.enrollmentResult);
@@ -228,22 +179,10 @@ class Sca {
             return;
         }
         if (scenario.outcome.success) {
-            const message = `FatZebra.3DS: 3DS success - ${scenario.description}.`;
-            emit(PublicEvent.SCA_SUCCESS, {
-                message,
-                data: threedsData,
-            });
-            console.log(message);
+            this.reportSuccess(`FatZebra.3DS: 3DS success - ${scenario.description}.`, threedsData);
         }
         else {
-            const message = `FatZebra.3DS: 3DS error - ${scenario.description}`;
-            emit(PublicEvent.SCA_ERROR, {
-                errors: [message],
-                data: {
-                    errorCode: scenario.outcome.errorCode
-                },
-            });
-            console.log(message);
+            this.reportFailure(`FatZebra.3DS: 3DS error - ${scenario.description} - ${scenario.outcome.errorCode}`);
         }
     }
 }

package/dist/sca/scenarios/index.d.ts

@@ -1,4 +1,5 @@
 export { enrollmentScenarios } from './enrollment';
-export type { EnrollmentScenario } from './enrollment';
 export { validationScenarios } from './validation';
-export type { ValidationScenario } from './validation';
+import type { EnrollmentScenario } from './enrollment';
+import type { ValidationScenario } from './validation';
+export type { EnrollmentScenario, ValidationScenario };

package/dist/sca/types.d.ts

@@ -155,5 +155,5 @@ interface GetCardRequest {
 interface GetCardResponse {
     bin: string;
 }
-export { ScaErrorCode, ChallengeWindowSize, CommerceIndicator, VEResEnrolled, PARes };
+export { ScaErrorCode, ChallengeWindowSize, CommerceIndicator, VEResEnrolled, PARes, };
 export type { CreateSCASessionRequest, CreateSCASessionResponse, EnrollSCARequest, EnrollSCAResponse, ValidateSCARequest, ValidateSCAResponse, DecodeSCASessionRequest, DecodeSCASessionResponse, GetCardRequest, GetCardResponse, ThreedsData };

package/dist/sca/types.js

@@ -51,4 +51,4 @@ var PARes;
     PARes["NOT_COMPLETED"] = "U";
     PARes["SUCCESS"] = "Y";
 })(PARes || (PARes = {}));
-export { ScaErrorCode, ChallengeWindowSize, CommerceIndicator, VEResEnrolled, PARes };
+export { ScaErrorCode, ChallengeWindowSize, CommerceIndicator, VEResEnrolled, PARes, };

package/dist/shared/api-gateway-client.d.ts

@@ -1,5 +1,6 @@
 import { AxiosResponse, AxiosInstance } from "axios";
 import * as sca from "../sca/types";
+import * as paypal from "../paypal/types";
 export type GatewayClientProps = {
     accessToken: string;
     username: string;
@@ -13,5 +14,11 @@ declare class GatewayClient {
     enrolSCA(data: sca.EnrollSCARequest): Promise<AxiosResponse>;
     validateSCA(data: sca.ValidateSCARequest): Promise<AxiosResponse>;
     getCard(data: sca.GetCardRequest): Promise<AxiosResponse>;
+    /**************** PayPal /****************/
+    createPayPalOrder(data: paypal.CreatePayPalOrderRequest): Promise<AxiosResponse>;
+    capturePayPalOrder(data: paypal.CapturePayPalOrderRequest): Promise<AxiosResponse>;
+    authorizePayPalOrder(data: paypal.AuthorizePayPalOrderRequest): Promise<AxiosResponse>;
+    createPayPalBillingAgreement(data: paypal.CreatePayPalBillingAgreementRequest): Promise<AxiosResponse>;
+    approvePayPalBillingAgreement(data: paypal.ApprovePayPalBillingAgreementRequest): Promise<AxiosResponse>;
 }
 export default GatewayClient;