@fat-zebra/sdk 2.0.1-beta.0 → 2.0.1-beta.1

package/dist/hpp/hpp.js

@@ -10,8 +10,8 @@ import { emit, off, on } from '../shared/event-manager';
 import { PostMessageClient } from '../shared/post-message-client';
 import { BridgeEvent, PublicEvent, } from '../shared/types';
 import * as util from '../shared/util';
-import { logMethod } from "../logging/logMethod";
 import { setTransactionReference } from "../logging/logger-context";
+import { logMethod } from "../logging/logMethod";
 import ThreeDSecure from "../three_d_secure";
 const HPP_DEFAULT_OPTIONS = {
     enableSca: false,
@@ -147,8 +147,7 @@ class Hpp {
                         merchantUsername: this.username,
                         cardToken: this.cardToken,
                         test: this.test,
-                        challengeWindowSize: this.challengeWindowSize,
-                        tokenizeOnly: false
+                        challengeWindowSize: this.challengeWindowSize
                     });
                     return; // do not continue execution to old 3DS
                 }

package/dist/main.d.ts

@@ -27,10 +27,9 @@ export default class FatZebra {
     private sca;
     private fzConfig;
     private gatewayClient;
-    private headless;
     constructor(config: FZConfig);
-    tokenizeCard(card: Card): void;
-    cardDidTokenize(callback: (data: any) => void): void;
+    tokenizeCard(card: Card, headless: HTMLIFrameElement): void;
+    cardDidTokenize(headless: HTMLIFrameElement, callback: (data: any) => void): void;
     verifyCard(params: VerifyCardParams): Promise<void>;
     renderPaymentsPage(params: HppLoadParams): void;
     renderApplePayButton(params: ApplePayParams): void;

package/dist/main.js

@@ -27,7 +27,6 @@ import { validateApplePayLoadParams } from "./validation/validators/apple-pay-lo
 import { ApplePay } from "./applepay";
 import { setLoggerUsername } from "./logging/logger-context";
 import { logMethod } from "./logging/logMethod";
-import ThreeDSecure from "./three_d_secure";
 export default class FatZebra {
     constructor(config) {
         setLoggerUsername(config.username);
@@ -41,28 +40,29 @@ export default class FatZebra {
             gatewayClient: this.gatewayClient,
         });
         this.sca.loadScript();
-        this.headless = bridge.load(process.env.PAYNOW_BRIDGE_URL);
     }
-    tokenizeCard(card) {
+    tokenizeCard(card, headless) {
         const channel = 'sca';
-        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.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, '*');
         };
-        this.headless.contentWindow.postMessage(message, '*');
     }
-    cardDidTokenize(callback) {
+    cardDidTokenize(headless, callback) {
         const channel = 'sca';
         const postMessageClient = new PostMessageClient({
             channel,
-            target: this.headless
+            target: headless
         });
         const handlers = {};
         handlers[BridgeEvent.TOKENIZE_CARD_RESPONSE] = (data) => {
@@ -81,44 +81,35 @@ export default class FatZebra {
                 });
                 return;
             }
-            const threeDSecure = new ThreeDSecure({
-                bridge: this.headless,
-                environment: process.env.API_ENV
-            });
             switch (params.paymentMethod.type) {
                 case PaymentMethodType.CARD:
+                    const headless = bridge.load(process.env.PAYNOW_BRIDGE_URL);
                     const card = params.paymentMethod.data;
-                    this.cardDidTokenize((data) => __awaiter(this, void 0, void 0, function* () {
+                    this.cardDidTokenize(headless, (data) => __awaiter(this, void 0, void 0, function* () {
                         var _a;
-                        threeDSecure.run({
-                            paymentIntent: params.paymentIntent,
+                        const bin = card.number.substr(0, 6);
+                        this.sca.run({
                             cardToken: data.token,
-                            merchantUsername: this.fzConfig.username,
+                            customer: params.customer,
+                            paymentIntent: params.paymentIntent,
+                            bin,
                             challengeWindowSize: (_a = params.options) === null || _a === void 0 ? void 0 : _a.challengeWindowSize,
-                            test: this.fzConfig.test,
-                            tokenizeOnly: true
                         });
                     }));
-                    this.tokenizeCard(card);
+                    this.tokenizeCard(card, headless);
                     break;
                 case PaymentMethodType.CARD_ON_FILE:
                     const cardToken = params.paymentMethod.data.token;
-                    threeDSecure.run({
+                    const bin = (yield this.gatewayClient.getCard({ card_token: cardToken })).data.bin;
+                    this.sca.run({
+                        cardToken,
+                        customer: params.customer,
                         paymentIntent: params.paymentIntent,
-                        cardToken: cardToken,
-                        merchantUsername: this.fzConfig.username,
+                        bin,
                         challengeWindowSize: (_a = params.options) === null || _a === void 0 ? void 0 : _a.challengeWindowSize,
-                        test: this.fzConfig.test,
-                        tokenizeOnly: true
                     });
                     break;
             }
-            const channel = 'sca';
-            const postMessageClient = new PostMessageClient({
-                channel,
-                target: this.headless
-            });
-            postMessageClient.setEventListeners(threeDSecure.messageHandlers());
         });
     }
     renderPaymentsPage(params) {

package/dist/react/useMessage.js

@@ -44,8 +44,7 @@ const useMessage = ({ paymentIntent, options, handlers, sca, config }) => {
                 paymentIntent,
                 cardToken: data.token,
                 merchantUsername: config.username,
-                test: config.environment !== Environment.production,
-                tokenizeOnly: config.options.tokenize_only
+                test: config.environment !== Environment.production
             });
             return;
         }

package/dist/three_d_secure/index.d.ts

@@ -20,16 +20,14 @@ declare class ThreeDSecure {
     private challengeWindowSize;
     private successCallback;
     private failureCallback;
-    private tokenizeOnly;
     private iframe?;
     constructor({ successCallback, failureCallback, environment, bridge, iframe }: ThreeDSecureConfig);
-    run({ paymentIntent, cardToken, merchantUsername, challengeWindowSize, test, tokenizeOnly }: {
+    run({ paymentIntent, cardToken, merchantUsername, challengeWindowSize, test }: {
         paymentIntent: PaymentIntent;
         cardToken: string;
         merchantUsername: string;
         challengeWindowSize?: ChallengeWindowSize;
         test: boolean;
-        tokenizeOnly?: boolean;
     }): void;
     setupResponse(data: DeviceDataCollectionMessage): void;
     messageHandlers(): {

package/dist/three_d_secure/index.js

@@ -19,7 +19,6 @@ import { ChallengeWindowSize } from "../sca/types";
 import * as util from "../shared/util";
 class ThreeDSecure {
     constructor({ successCallback, failureCallback, environment, bridge, iframe }) {
-        this.tokenizeOnly = false;
         this.headlessBridge = bridge;
         this.environment = environment;
         this.successCallback = successCallback;
@@ -27,8 +26,7 @@ class ThreeDSecure {
         this.iframe = iframe;
         DeviceDataCollection.listenDataCollectionResponse(environment);
     }
-    run({ paymentIntent, cardToken, merchantUsername, challengeWindowSize, test, tokenizeOnly }) {
-        this.tokenizeOnly = tokenizeOnly;
+    run({ paymentIntent, cardToken, merchantUsername, challengeWindowSize, test }) {
         this.setLoading();
         this.paymentIntent = paymentIntent;
         this.test = test;
@@ -126,8 +124,6 @@ class ThreeDSecure {
         if (scenario.outcome.success) {
             this.reportSuccess(`FatZebra.3DS: 3DS success - ${scenario.description}.`, threeDSecureData);
             const extra = util.toObjectWithSnakeCaseKeys(threeDSecureData);
-            if (this.tokenizeOnly)
-                return; // DO NO process purchase if tokenizing only.
             this.createPurchase(extra);
             return;
         }
@@ -153,8 +149,6 @@ class ThreeDSecure {
         const extra = util.toObjectWithSnakeCaseKeys(threeDSecureData);
         if (scenario.outcome.success) {
             this.reportSuccess(`FatZebra.3DS: 3DS success - ${scenario.description}.`, threeDSecureData);
-            if (this.tokenizeOnly)
-                return; // DO NO process purchase if tokenizing only.
             this.createPurchase(extra);
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fat-zebra/sdk",
-  "version": "2.0.1-beta.0",
+  "version": "2.0.1-beta.1",
   "description": "",
   "main": "index.js",
   "scripts": {