@idonatedev/idonate-sdk 1.1.0-dev9 → 1.2.0-dev0

package/dist/esm/constants.js

@@ -0,0 +1,81 @@
+export const SDK_VERSION = '1.2.0-dev0';
+export const PRODUCTION_BASE_URL = 'https://secure-api.idonate.com';
+export const SANDBOX_BASE_URL = 'https://api.qa-idonate.com';
+export const PRODUCTION_CARD_CONNECT_BASE_URL = 'https://boltgw.cardconnect.com:8443';
+export const SANDBOX_CARD_CONNECT_BASE_URL = 'https://boltgw-uat.cardconnect.com';
+export const SPREEDLY_TOKENIZER_URL = 'https://core.spreedly.com/v1/payment_methods.json';
+export const APPLE_PAY_URL = 'https://apple-pay-gateway.apple.com/paymentservices/paymentSession';
+export const SANDBOX_APPLE_PAY_URL = 'https://apple-pay-gateway-cert.apple.com/paymentservices/paymentSession';
+export const FALLBACK_PC_SCRIPT_URL = 'https://p.idonate.com/r';
+export const FALLBACK_PC_SCRIPT_ID = '_3fd4dad26e8c277bc50fb2ddf8233b50bc8d9704';
+export const FALLBACK_CF_TURNSTILE_SITE_KEY = '0x4AAAAAAAxuRxNZTvX8shIj';
+export const DEFAULT_CF_TURNSTILE_CDN_EXPLICIT_URL = 'https://challenges.cloudflare.com/turnstile/v0/api.js';
+export const DEFAULT_APP_NAME = 'unnamed-sdk-client';
+export const CARD_CONNECT_DEFAULT_STYLE = `
+body {
+    margin: 0;
+}
+
+form {
+    display: flex;
+}
+
+label#cccardlabel {
+    display: none;
+}
+
+br {
+    display: none;
+}
+
+label#cccvvlabel {
+    display: none;
+}
+
+label#ccexpirylabel {
+    display: none;
+}
+
+input {
+    padding: 10px;
+}
+
+select {
+    padding: 10px;
+    font-size: 14px;
+    color: #8b959d;
+}
+
+select#ccexpirymonth {
+    margin-right: -30px;
+    border: 1px solid #b6b8ba;
+    border-right: 0;
+}
+
+input#ccnumfield {
+    width: 70%;
+    border: 1px solid #b6b8ba;
+    border-right: 0;
+    border-top-left-radius: 3px;
+    border-bottom-left-radius: 3px;
+    font-size: 14px;
+    color: #8b959d;
+}
+
+select#ccexpiryyear {
+    border: 1px solid #b6b8ba;
+    border-right: 0;
+}
+
+input#cccvvfield {
+    border: 1px solid #b6b8ba;
+    border-top-right-radius: 3px;
+    border-bottom-right-radius: 3px;
+    font-size: 14px;
+    color: #8b959d;
+}
+`.replace(/\s+/gi, ' ');
+export const CLIENT_HEADERS = {
+    'User-Agent': navigator.userAgent + ` idonate-sdk@${SDK_VERSION}`,
+    'Content-Type': 'application/json',
+};

package/dist/esm/google-pay.d.ts

@@ -0,0 +1,18 @@
+import { TokenizeCardConnectGooglePayResult, GooglePayConfig } from './types';
+export default class GooglePay {
+    private static resolveLib;
+    static injectScript(): void;
+    private baseRequest;
+    private baseCardPaymentMethod;
+    private transactionInfo;
+    private tokenizationSpecification;
+    private googlePayOptions;
+    private readonly paymentRequestDefaults;
+    private paymentRequest;
+    paymentsClient: google.payments.api.PaymentsClient | null;
+    constructor(googlePayConfig: GooglePayConfig);
+    getGoogleIsReadyToPayRequest(): google.payments.api.IsReadyToPayRequest;
+    getGooglePaymentClient(): Promise<google.payments.api.PaymentsClient>;
+    onGooglePaymentButtonClicked(transactionInfoUpdate: Partial<google.payments.api.TransactionInfo>): Promise<google.payments.api.PaymentData>;
+    tokenizeWithCardConnect(paymentToken: string, cardConnectBaseUrl: string): Promise<TokenizeCardConnectGooglePayResult>;
+}

package/dist/esm/google-pay.js

@@ -0,0 +1,140 @@
+export default class GooglePay {
+    static resolveLib(options) {
+        const startWait = new Date();
+        return new Promise((resolve, reject) => {
+            function poll() {
+                if (window.google !== undefined &&
+                    window.google.payments !== undefined) {
+                    const paymentsClient = new google.payments.api.PaymentsClient(options);
+                    resolve(paymentsClient);
+                }
+                else {
+                    const elapsedMs = new Date().valueOf() - startWait.valueOf();
+                    if (elapsedMs > 15000) {
+                        reject(new Error('pay.js not loaded after 15 seconds'));
+                    }
+                    else {
+                        setTimeout(poll, 250);
+                    }
+                }
+            }
+            poll();
+        });
+    }
+    static injectScript() {
+        if (window.google !== undefined && window.google.payments !== undefined) {
+            throw new Error('google payments is already injected');
+        }
+        const script = document.createElement('script');
+        script.src = 'https://pay.google.com/gp/p/js/pay.js?render=explicit';
+        script.async = true;
+        script.defer = true;
+        document.body.appendChild(script);
+    }
+    constructor(googlePayConfig) {
+        this.baseRequest = {
+            apiVersion: 2,
+            apiVersionMinor: 0,
+        };
+        this.baseCardPaymentMethod = {
+            type: 'CARD',
+            parameters: {
+                allowedAuthMethods: ['PAN_ONLY', 'CRYPTOGRAM_3DS'],
+                allowedCardNetworks: [
+                    'AMEX',
+                    'DISCOVER',
+                    'INTERAC',
+                    'JCB',
+                    'MASTERCARD',
+                    'VISA',
+                ],
+                billingAddressRequired: true,
+                billingAddressParameters: {
+                    format: 'FULL',
+                    phoneNumberRequired: true,
+                },
+            },
+        };
+        this.transactionInfo = {
+            countryCode: 'US',
+            currencyCode: 'USD',
+            totalPriceStatus: 'FINAL',
+            totalPrice: '',
+        };
+        this.tokenizationSpecification = {
+            type: 'PAYMENT_GATEWAY',
+            parameters: {
+                gateway: 'cardconnect',
+                gatewayMerchantId: '',
+            },
+        };
+        this.googlePayOptions = {
+            environment: 'PRODUCTION',
+        };
+        this.paymentRequestDefaults = Object.assign(Object.assign({}, this.baseRequest), { merchantInfo: {
+                merchantId: '',
+            }, transactionInfo: this.transactionInfo, emailRequired: true, allowedPaymentMethods: [
+                Object.assign(Object.assign({}, this.baseCardPaymentMethod), { tokenizationSpecification: this.tokenizationSpecification }),
+            ] });
+        this.paymentsClient = null;
+        const { paymentOptions, cardConnectMerchantId, paymentDataRequest, baseCardPaymentMethodParameters = {}, } = googlePayConfig;
+        this.tokenizationSpecification.parameters.gatewayMerchantId =
+            cardConnectMerchantId;
+        this.paymentRequest = Object.assign({}, this.paymentRequestDefaults, paymentDataRequest);
+        this.googlePayOptions = Object.assign({}, this.googlePayOptions, Object.assign(Object.assign({}, paymentOptions), { merchantInfo: this.paymentRequest.merchantInfo }));
+        this.baseCardPaymentMethod.parameters = Object.assign(Object.assign({}, this.baseCardPaymentMethod.parameters), baseCardPaymentMethodParameters);
+    }
+    getGoogleIsReadyToPayRequest() {
+        return Object.assign({}, this.baseRequest, {
+            allowedPaymentMethods: [this.baseCardPaymentMethod],
+        });
+    }
+    getGooglePaymentClient() {
+        return new Promise((resolve, reject) => {
+            if (!this.paymentsClient) {
+                GooglePay.resolveLib(this.googlePayOptions)
+                    .then((client) => {
+                    this.paymentsClient = client;
+                    resolve(client);
+                })
+                    .catch((err) => reject(err));
+            }
+            else {
+                resolve(this.paymentsClient);
+            }
+        });
+    }
+    onGooglePaymentButtonClicked(transactionInfoUpdate) {
+        const paymentDataRequest = this.paymentRequest;
+        this.transactionInfo = Object.assign({}, this.transactionInfo, transactionInfoUpdate);
+        paymentDataRequest.transactionInfo = this.transactionInfo;
+        return new Promise((resolve, reject) => {
+            if (!this.paymentsClient) {
+                reject(new Error('PaymentClient is not initialized'));
+            }
+            else {
+                this.paymentsClient
+                    .loadPaymentData(paymentDataRequest)
+                    .then((paymentData) => {
+                    resolve(paymentData);
+                })
+                    .catch((err) => {
+                    reject(err);
+                });
+            }
+        });
+    }
+    tokenizeWithCardConnect(paymentToken, cardConnectBaseUrl) {
+        return fetch(`${cardConnectBaseUrl}/cardsecure/api/v1/ccn/tokenize`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                encryptionhandler: 'EC_GOOGLE_PAY',
+                devicedata: paymentToken,
+                unique: true,
+            }),
+        }).then((response) => response.json());
+    }
+}

package/dist/esm/idonate-client.d.ts

@@ -0,0 +1,32 @@
+import { ClientOptions, Contact, Address, CreatePaymentMethodRequest, CreatePaymentMethodResult, CreateDonationRequest, CreateDonationResult, TokenizeApplePayResult, EmbedConfig } from './types';
+import ConfigHandler from './config-handler';
+import { Tokenizer, PaymentMethodType, PaymentGateway, TokenizerContainer } from './tokenize';
+export default class iDonateClient {
+    private readonly clientKey;
+    private readonly embedId;
+    private currentOrganizationId;
+    private allowTransaction;
+    private embedConfigCache?;
+    private embedConfigPromise?;
+    get organizationId(): string;
+    readonly options: ClientOptions;
+    readonly config: ConfigHandler;
+    constructor(clientKey: string, embedId: string | EmbedConfig, options?: Partial<ClientOptions>);
+    createDonation(donation: CreateDonationRequest): Promise<CreateDonationResult>;
+    createTransaction(donation: CreateDonationRequest): Promise<{
+        transactionId: string | undefined;
+        _raw_response: any;
+    }>;
+    createPaymentMethod(paymentMethod: CreatePaymentMethodRequest): Promise<CreatePaymentMethodResult>;
+    setOrganizationId(organizationId: string): void;
+    waitForDonationResult(donationId: string, afterEachCheck?: () => void): Promise<any>;
+    tokenizeCardConnectApplePay(applePayRequest: Partial<ApplePayJS.ApplePayPaymentRequest>): Promise<TokenizeApplePayResult>;
+    createTokenizer(gateway: PaymentGateway, container: TokenizerContainer): Promise<Tokenizer>;
+    tokenizeSpreedlyPayPal(data: {
+        contact: Contact;
+        address: Address;
+    }): Promise<string>;
+    selectGateway(availableGateways: PaymentGateway[], paymentType: PaymentMethodType, preferredGatewayId?: string): PaymentGateway | undefined;
+    getEmbedConfig(): Promise<EmbedConfig>;
+    getGateway(gatewayId: string): Promise<PaymentGateway>;
+}

package/dist/esm/idonate-client.js

@@ -0,0 +1,294 @@
+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 { ClientError, } from './types';
+import { buildDonationResult, buildCashPaymentPayload } from './typeAdapters';
+import { CLIENT_HEADERS, SDK_VERSION } from './constants';
+import { parseResponse } from './util';
+import ApplePay from './apple-pay';
+import ConfigHandler from './config-handler';
+import { SpreedlyTokenizer } from './tokenize/SpreedlyTokenizer';
+import * as shared from './shared';
+import { v4 as uuidv4 } from 'uuid';
+import { handleCFChallenge } from './cloudflare-challenge-handler';
+import { Tokenizer, } from './tokenize';
+const clientDefaults = {
+    enableSandboxMode: false,
+    overrideBaseUrl: undefined,
+    enableDelay: false,
+    secondsToDelay: 0,
+};
+export default class iDonateClient {
+    get organizationId() {
+        if (!this.currentOrganizationId) {
+            throw new Error('organizationId undefined');
+        }
+        return this.currentOrganizationId;
+    }
+    constructor(clientKey, embedId, options) {
+        var _a;
+        this.clientKey = clientKey;
+        if (typeof embedId === 'string') {
+            this.embedId = embedId;
+        }
+        else {
+            this.embedConfigCache = embedId;
+            this.embedId = embedId.embed_id || '';
+            if (embedId.organization_id) {
+                this.currentOrganizationId = embedId.organization_id;
+            }
+        }
+        if (!this.currentOrganizationId) {
+            this.currentOrganizationId = clientKey;
+        }
+        this.options = Object.assign({}, clientDefaults, options);
+        this.allowTransaction = false;
+        this.config = new ConfigHandler(this.options);
+        const configEntries = Object.entries(this.config);
+        for (const [key, value] of configEntries) {
+            const descriptor = Object.getOwnPropertyDescriptor(this, key);
+            if (!descriptor || descriptor.set !== undefined) {
+                try {
+                    this[key] = value;
+                }
+                catch (e) {
+                }
+            }
+        }
+        if (this.options.enableDelay && this.options.secondsToDelay) {
+            const delay = this.options.secondsToDelay * 1000;
+            setTimeout(() => {
+                this.allowTransaction = true;
+            }, delay);
+        }
+        else {
+            this.allowTransaction = true;
+        }
+        if (this.options.enableSandboxMode && console !== undefined) {
+            console.info(`[Sandbox] iDonate SDK Configuration (v${SDK_VERSION}):`, JSON.parse(JSON.stringify(this)));
+        }
+        try {
+            const { pcScriptBase, pcScriptId } = this.config;
+            if (!pcScriptBase || !pcScriptId) {
+                throw new Error('missing config');
+            }
+            const uuid = uuidv4();
+            const script = window.document.createElement('script');
+            script.setAttribute('src', pcScriptBase + '/' + uuid + '.js');
+            script.setAttribute('id', pcScriptId);
+            let appended = false;
+            const appendScript = () => {
+                var _a;
+                try {
+                    if (appended)
+                        return;
+                    window.document.body.append(script);
+                    appended = true;
+                }
+                catch (e) {
+                    (_a = console === null || console === void 0 ? void 0 : console.warn) === null || _a === void 0 ? void 0 : _a.call(console, 'not appended');
+                }
+            };
+            appendScript();
+            window.addEventListener('DOMContentLoaded', () => {
+                window.document.body.append(script);
+            });
+        }
+        catch (e) {
+            (_a = console === null || console === void 0 ? void 0 : console.warn) === null || _a === void 0 ? void 0 : _a.call(console, 'Warning, partial initialization: ', String(e));
+        }
+        if (!this.currentOrganizationId) {
+            this.setOrganizationId(this.clientKey);
+        }
+    }
+    createDonation(donation) {
+        if (!this.allowTransaction) {
+            throw new Error('Wow, that was fast - try again');
+        }
+        if (!donation.embedId) {
+            donation.embedId = this.embedId;
+        }
+        const payload = buildCashPaymentPayload(this.organizationId, donation);
+        const fetchCall = (clearanceToken) => fetch(`${this.config.embedApiBaseUrl}/donate/cash-payment`, {
+            method: 'POST',
+            headers: Object.assign(Object.assign(Object.assign({}, CLIENT_HEADERS), (clearanceToken ? { 'cf-validation-token': clearanceToken } : {})), { 'User-Agent': CLIENT_HEADERS['User-Agent'] + ' source:' + this.config.client }),
+            body: JSON.stringify(payload),
+            credentials: 'include',
+        });
+        return (fetchCall()
+            .then((response) => __awaiter(this, void 0, void 0, function* () {
+            if (response.headers.get('cf-mitigated') === 'challenge') {
+                const clearance = yield handleCFChallenge(response, this);
+                return fetchCall(clearance === null || clearance === void 0 ? void 0 : clearance.token);
+            }
+            return response;
+        }))
+            .then((response) => parseResponse(response, { throwErrors: true }))
+            .then((response) => buildDonationResult(response)));
+    }
+    createTransaction(donation) {
+        return this.createDonation(donation).then((result) => {
+            var _a;
+            return {
+                transactionId: (_a = result.transaction) === null || _a === void 0 ? void 0 : _a.id,
+                _raw_response: result._raw_response,
+            };
+        });
+    }
+    createPaymentMethod(paymentMethod) {
+        if (!paymentMethod.embedId) {
+            paymentMethod.embedId = this.embedId;
+        }
+        return shared.createPaymentMethod(paymentMethod, this.config);
+    }
+    setOrganizationId(organizationId) {
+        this.currentOrganizationId = organizationId;
+    }
+    waitForDonationResult(donationId, afterEachCheck) {
+        function isReady(response) {
+            return !!response.processed && !!response.transaction;
+        }
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                let pollHandle;
+                pollHandle = setInterval(() => {
+                    fetch(`${this.config.embedApiBaseUrl}/donate/cash-payment/${donationId}/payment_status`, {
+                        method: 'GET',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                    })
+                        .then((response) => response.json())
+                        .then((rawResponse) => rawResponse.result)
+                        .then((response) => {
+                        if (isReady(response)) {
+                            if (pollHandle) {
+                                clearInterval(pollHandle);
+                                pollHandle = null;
+                            }
+                            if (response.error) {
+                                reject(new ClientError(response.error));
+                            }
+                            resolve(buildDonationResult({
+                                _raw_response: Object.assign({ campaign: null, designation: {}, donor: {}, form_data: {}, id: null, schedule: {}, transaction: {} }, response),
+                            }));
+                        }
+                        else {
+                        }
+                        afterEachCheck === null || afterEachCheck === void 0 ? void 0 : afterEachCheck();
+                    })
+                        .catch((e) => {
+                        if (pollHandle) {
+                            clearInterval(pollHandle);
+                            pollHandle = null;
+                        }
+                        reject(e);
+                    });
+                }, 2000);
+            }, 2000);
+        });
+    }
+    tokenizeCardConnectApplePay(applePayRequest) {
+        const applePay = new ApplePay(applePayRequest);
+        let merchantSessionId = '';
+        const promiseStart = applePay.begin();
+        return new Promise((resolve, reject) => {
+            promiseStart
+                .then((session) => {
+                session.onvalidatemerchant = (event) => {
+                    const validationPayload = {
+                        apple_pay_url: this.config.applePayUrl,
+                        organization_id: this.organizationId,
+                    };
+                    applePay
+                        .createSession(validationPayload, this.config.embedApiBaseUrl)
+                        .then((merchantSession) => {
+                        merchantSessionId =
+                            merchantSession.result.merchantSessionIdentifier;
+                        session.completeMerchantValidation(merchantSession.result);
+                    })
+                        .catch((err) => {
+                        session.abort();
+                        reject(err);
+                    });
+                };
+                session.onpaymentauthorized = (event) => {
+                    applePay
+                        .tokenizeWithCardConnect(event.payment, this.config.cardConnectBaseUrl)
+                        .then((data) => {
+                        var _a, _b;
+                        const unifiedContact = Object.assign(Object.assign({}, event.payment.billingContact), { email: (_a = event.payment.shippingContact) === null || _a === void 0 ? void 0 : _a.emailAddress, phone: (_b = event.payment.shippingContact) === null || _b === void 0 ? void 0 : _b.phoneNumber });
+                        const result = {
+                            applePaySession: session,
+                            cardConnectResponse: data,
+                            billingContact: unifiedContact,
+                            merchantSessionId,
+                        };
+                        resolve(result);
+                    })
+                        .catch((err) => {
+                        session.abort();
+                        reject(err);
+                    });
+                };
+                session.oncancel = (event) => {
+                    reject(new Error('Apple Pay has been closed'));
+                };
+            })
+                .catch((err) => reject(err));
+        });
+    }
+    createTokenizer(gateway, container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Tokenizer.create(gateway, container, {
+                organizationId: this.organizationId,
+                embedId: this.embedId,
+                clientConfig: this.config,
+            });
+        });
+    }
+    tokenizeSpreedlyPayPal(data) {
+        return SpreedlyTokenizer.tokenizePayPal(data, this.config);
+    }
+    selectGateway(availableGateways, paymentType, preferredGatewayId) {
+        if (preferredGatewayId) {
+            const preferred = availableGateways.find((g) => g.id === preferredGatewayId);
+            if (preferred)
+                return preferred;
+        }
+        return availableGateways[0];
+    }
+    getEmbedConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.embedConfigCache) {
+                return this.embedConfigCache;
+            }
+            if (this.embedConfigPromise) {
+                return this.embedConfigPromise;
+            }
+            this.embedConfigPromise = shared
+                .fetchEmbedConfig(this.embedId, this.config)
+                .then((config) => {
+                this.embedConfigCache = config;
+                return config;
+            });
+            return this.embedConfigPromise;
+        });
+    }
+    getGateway(gatewayId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield this.getEmbedConfig();
+            const gateway = config.available_gateways.find((g) => g.id === gatewayId);
+            if (!gateway) {
+                throw new Error(`Gateway ${gatewayId} not found in embed configuration. Available: ${config.available_gateways.map((g) => g.id).join(', ')}`);
+            }
+            return gateway;
+        });
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,11 @@
+import * as tokenize from './tokenize';
+import * as util from './util';
+import * as recaptcha from './recaptcha';
+import * as constants from './constants';
+import * as shared from './shared';
+import iDonateClient from './idonate-client';
+import ConfigHandler from './config-handler';
+import ApplePay from './apple-pay';
+import GooglePay from './google-pay';
+export * from './types';
+export { tokenize, util, shared, iDonateClient as Client, ConfigHandler, recaptcha, constants, ApplePay, GooglePay, };

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+import * as tokenize from './tokenize';
+import * as util from './util';
+import * as recaptcha from './recaptcha';
+import * as constants from './constants';
+import * as shared from './shared';
+import iDonateClient from './idonate-client';
+import ConfigHandler from './config-handler';
+import ApplePay from './apple-pay';
+import GooglePay from './google-pay';
+export * from './types';
+export { tokenize, util, shared, iDonateClient as Client, ConfigHandler, recaptcha, constants, ApplePay, GooglePay, };

package/dist/esm/recaptcha.d.ts

@@ -0,0 +1,12 @@
+export declare function injectScript(callback?: () => void): void;
+export declare class RecaptchaElement {
+    private readonly container;
+    private readonly params;
+    private widgetId;
+    private executeResolveQueue;
+    private resolvedToken;
+    constructor(container: string, params: ReCaptchaV2.Parameters);
+    render(): Promise<void>;
+    resolveToken(): Promise<string>;
+}
+export declare function wrapElement(container: string, sitekey: string, extraParams?: any): RecaptchaElement;