judokit-react-native 4.1.3 → 4.2.0

package/src/judo-kit/index.ts

@@ -0,0 +1,262 @@
+import type {
+  JudoAuthorization,
+  JudoConfiguration,
+  JudoResponse,
+  JudoTransactionMode,
+  JudoTransactionType,
+} from '../types';
+
+import { version as packageVersion } from '../../package.json';
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'judokit-react-native' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const JudoKitReactNative = NativeModules.JudoKitReactNative
+  ? NativeModules.JudoKitReactNative
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+// TODO: Rename this to `JudoKit`.
+export class JudoPay {
+  //------------------------------------------------------------------
+  // Private properties
+  //------------------------------------------------------------------
+
+  private readonly authorization: JudoAuthorization;
+
+  //------------------------------------------------------------------
+  // Public properties
+  //------------------------------------------------------------------
+
+  /**
+   * This property is used to toggle the sandbox environment on and off.
+   * You can use the sandbox environment to test our SDK features.
+   */
+  public isSandboxed = true;
+
+  //------------------------------------------------------------------
+  // Initializers
+  //------------------------------------------------------------------
+
+  /**
+   * The designated initializer that is used to configure the JudoPay session, based
+   * on a provided object that implements the JudoAuthorization interface.
+   *
+   * @param authorization - can be either a JudoBasicAuthorization (token & secret) or
+   * a JudoSessionAuthorization (token & payment session) instance.
+   */
+  constructor(authorization: JudoAuthorization) {
+    this.authorization = authorization;
+  }
+
+  //------------------------------------------------------------------
+  // SDK Features
+  //------------------------------------------------------------------
+
+  /**
+   * A method used to verify if ApplePay is supported for given configuration object
+   *
+   * This needs to be invoked before invoking ApplePay transactions.
+   *
+   * @returns an asynchronous boolean value that indicates if ApplePay is available.
+   */
+  public isApplePayAvailableWithConfiguration(
+    configuration: JudoConfiguration
+  ): Promise<boolean> {
+    const params = this.generateJudoParameters(configuration);
+    return JudoKitReactNative.isApplePayAvailableWithConfiguration(params);
+  }
+
+  /**
+   * A method for invoking the Judo UI for card transactions.
+   * Supported operations - payments, pre-auths, register card, save card, check card.
+   *
+   * @param type - a JudoTransactionType value that defines the transaction type.
+   * @param configuration - a JudoConfiguration object that is used to configure/customize the payment flow.
+   *
+   * @returns an asynchronous JudoResponse object, containing the transaction results.
+   */
+  public async invokeTransaction(
+    type: JudoTransactionType,
+    configuration: JudoConfiguration
+  ): Promise<JudoResponse> {
+    const params = {
+      ...this.generateTransactionTypeParameters(type, configuration),
+      packageVersion,
+    };
+    return JudoKitReactNative.invokeTransaction(params);
+  }
+
+  public async fetchTransactionDetails(
+    receiptId: string
+  ): Promise<JudoResponse> {
+    const params = {
+      authorization: this.generateAuthorizationParameters(),
+      sandboxed: this.isSandboxed,
+      receiptId,
+      packageVersion,
+    };
+
+    return JudoKitReactNative.fetchTransactionDetails(params);
+  }
+
+  /**
+   * A method for completing a payment/pre-auth transaction using a saved card token.
+   *
+   * @param mode - a JudoTransactionMode value that defines if the transaction is either a payment or pre-auth.
+   * @param configuration - a JudoConfiguration object that is used to configure/customize the payment flow.
+   * @param cardToken - the saved card token string.
+   * @param securityCode - the saved card token security code.
+   * @param cardholderName - the saved card token cardholder name.
+   * @param cardScheme - the saved card token scheme name.
+   *
+   * @returns an asynchronous JudoResponse object, containing the transaction results.
+   */
+  public async performTokenTransaction(
+    mode: JudoTransactionMode,
+    configuration: JudoConfiguration,
+    cardToken: string,
+    securityCode: string | undefined | null,
+    cardholderName: string | undefined | null,
+    cardScheme: string
+  ): Promise<JudoResponse> {
+    const params = {
+      ...this.generateTransactionModeParameters(mode, configuration),
+      ...{
+        cardToken,
+        securityCode,
+        cardholderName,
+        cardScheme,
+      },
+      packageVersion,
+    };
+    return JudoKitReactNative.performTokenTransaction(params);
+  }
+
+  /**
+   * A method for invoking Apple Pay transactions.
+   * For this transaction to work, the required JudoApplePayConfiguration parameters must be present as part of
+   * the JudoConfiguration object passed to the method.
+   *
+   * @param mode - a JudoTransactionMode value that defines if the transaction is either a payment or pre-auth.
+   * @param configuration - a JudoConfiguration object that is used to configure/customize the payment flow.
+   *
+   * @returns an asynchronous JudoResponse object, containing the transaction results.
+   */
+  public async invokeApplePay(
+    mode: JudoTransactionMode,
+    configuration: JudoConfiguration
+  ): Promise<JudoResponse> {
+    const params = {
+      ...this.generateTransactionModeParameters(mode, configuration),
+      packageVersion,
+    };
+    return JudoKitReactNative.invokeApplePay(params);
+  }
+
+  /**
+   * A method for invoking Google Pay transactions.
+   * For this transaction to work, the required JudoGooglePayConfiguration parameters must be present as part of
+   * the JudoConfiguration object passed to the method.
+   *
+   * @param mode - a JudoTransactionMode value that defines if the transaction is either a payment or pre-auth.
+   * @param configuration - a JudoConfiguration object that is used to configure/customize the payment flow.
+   *
+   * @returns an asynchronous JudoResponse object, containing the transaction results.
+   */
+  public async invokeGooglePay(
+    mode: JudoTransactionMode,
+    configuration: JudoConfiguration
+  ): Promise<JudoResponse> {
+    const params = {
+      ...this.generateTransactionModeParameters(mode, configuration),
+      packageVersion,
+    };
+    return JudoKitReactNative.invokeGooglePay(params);
+  }
+
+  /**
+   * A method for invoking the Judo wallet, allowing users to pay with their preferred payment method.
+   * (Cards, Apple Pay/Google Pay, iDEAL)
+   *
+   * @param mode - a JudoTransactionMode value that defines if the transaction is either a payment or pre-auth.
+   * @param configuration - a JudoConfiguration object that is used to configure/customize the payment flow.
+   *
+   * @returns an asynchronous JudoResponse object, containing the transaction results.
+   */
+  public async invokePaymentMethodScreen(
+    mode: JudoTransactionMode,
+    configuration: JudoConfiguration
+  ): Promise<JudoResponse> {
+    const params = {
+      ...this.generateTransactionModeParameters(mode, configuration),
+      packageVersion,
+    };
+    return JudoKitReactNative.invokePaymentMethodScreen(params);
+  }
+
+  //------------------------------------------------------------------
+  // Private helper methods
+  //------------------------------------------------------------------
+
+  private readonly generateJudoParameters = (
+    configuration: JudoConfiguration
+  ): Record<string, any> => {
+    return {
+      authorization: this.generateAuthorizationParameters(),
+      sandboxed: this.isSandboxed,
+      configuration: configuration,
+    };
+  };
+
+  private readonly generateTransactionTypeParameters = (
+    type: JudoTransactionType,
+    configuration: JudoConfiguration
+  ): Record<string, any> => {
+    return {
+      authorization: this.generateAuthorizationParameters(),
+      sandboxed: this.isSandboxed,
+      transactionType: type,
+      configuration: configuration,
+    };
+  };
+
+  private readonly generateTransactionModeParameters = (
+    mode: JudoTransactionMode,
+    configuration: JudoConfiguration
+  ): Record<string, any> => {
+    return {
+      authorization: this.generateAuthorizationParameters(),
+      sandboxed: this.isSandboxed,
+      transactionMode: mode,
+      configuration: configuration,
+    };
+  };
+
+  private readonly generateAuthorizationParameters = (): Record<
+    string,
+    any
+  > => {
+    if (this.authorization.secret) {
+      return {
+        token: this.authorization.token,
+        secret: this.authorization.secret,
+      };
+    }
+
+    return {
+      token: this.authorization.token,
+      paymentSession: this.authorization.paymentSession,
+    };
+  };
+}

package/src/types/index.ts

@@ -0,0 +1,53 @@
+export {
+  ChallengeRequestIndicator,
+  ScaExemption,
+  JudoTransactionType,
+  JudoTransactionMode,
+  JudoTransactionResult,
+  JudoThreeDSButtonType,
+  JudoPaymentMethod,
+  JudoCardNetwork,
+  // type exports
+  JudoConfiguration,
+  NetworkTimeout,
+  JudoAmount,
+  JudoReference,
+  JudoAddress,
+  JudoThreeDSToolbarCustomization,
+  JudoThreeDSLabelCustomization,
+  JudoThreeDSTextBoxCustomization,
+  JudoThreeDSButtonCustomization,
+  JudoThreeDSUIConfiguration,
+  JudoUIConfiguration,
+  JudoTheme,
+  JudoAccountDetails,
+  JudoCardDetails,
+  JudoConsumer,
+  JudoResponse,
+  JudoAuthorization,
+} from './judo-configuration';
+
+export {
+  JudoPaymentSummaryItemType,
+  JudoMerchantCapability,
+  JudoContactField,
+  JudoShippingType,
+  JudoReturnedInfo,
+  // type exports
+  JudoPaymentSummaryItem,
+  JudoShippingMethod,
+  JudoApplePayConfiguration,
+  JudoApplePayRecurringPaymentRequest,
+  JudoRecurringPaymentSummaryItem,
+  JudoCalendarUnit,
+} from './judo-apple-pay-configuration';
+
+export {
+  JudoGooglePayEnvironment,
+  JudoAddressFormat,
+  JudoBillingAddressParameters,
+  JudoShippingAddressParameters,
+  JudoGooglePayPriceStatus,
+  JudoCheckoutOption,
+  JudoGooglePayConfiguration,
+} from './judo-google-pay-configuration';

package/src/types/judo-apple-pay-configuration.ts

@@ -0,0 +1,85 @@
+export enum JudoPaymentSummaryItemType {
+  Final,
+  Pending,
+}
+
+export interface JudoPaymentSummaryItem {
+  label: string;
+  amount: string;
+  type?: JudoPaymentSummaryItemType;
+}
+
+export enum JudoMerchantCapability {
+  ThreeDS = 1 << 0,
+  EMV = 1 << 1,
+  Credit = 1 << 2,
+  Debit = 1 << 3,
+  All = 1 << 4,
+}
+
+export enum JudoContactField {
+  PostalAddress = 1 << 0,
+  Phone = 1 << 1,
+  Email = 1 << 2,
+  Name = 1 << 3,
+  All = 1 << 4,
+}
+
+export interface JudoShippingMethod {
+  identifier: string;
+  detail: string;
+  label: string;
+  amount: string;
+  type: JudoPaymentSummaryItemType;
+}
+
+export enum JudoShippingType {
+  Shipping,
+  Delivery,
+  StorePickup,
+  ServicePickup,
+}
+
+export enum JudoReturnedInfo {
+  BillingDetails = 1 << 0,
+  ShippingDetails = 1 << 1,
+  All = 1 << 2,
+}
+
+export enum JudoCalendarUnit {
+  Year = 1,
+  Month,
+  Day,
+  Hour,
+  Minute,
+}
+
+export interface JudoRecurringPaymentSummaryItem
+  extends JudoPaymentSummaryItem {
+  startDate?: string;
+  endDate?: string;
+  intervalUnit?: JudoCalendarUnit;
+  intervalCount?: number;
+}
+
+export interface JudoApplePayRecurringPaymentRequest {
+  paymentDescription: string;
+  managementURL: string;
+  regularBilling: JudoRecurringPaymentSummaryItem;
+  trialBilling?: JudoRecurringPaymentSummaryItem;
+  billingAgreement?: string;
+  tokenNotificationURL?: string;
+}
+
+export interface JudoApplePayConfiguration {
+  merchantId: string;
+  countryCode: string;
+  paymentSummaryItems: JudoPaymentSummaryItem[];
+  merchantCapabilities?: JudoMerchantCapability;
+  requiredBillingContactFields?: JudoContactField;
+  requiredShippingContactFields?: JudoContactField;
+  shippingMethods?: JudoShippingMethod[];
+  shippingType?: JudoShippingType;
+  returnedInfo?: JudoReturnedInfo;
+  recurringPaymentRequest?: JudoApplePayRecurringPaymentRequest;
+}

package/src/types/judo-configuration.ts

@@ -0,0 +1,263 @@
+import { JudoApplePayConfiguration } from './judo-apple-pay-configuration';
+import { JudoGooglePayConfiguration } from './judo-google-pay-configuration';
+
+export interface JudoConfiguration {
+  judoId: string;
+  amount: JudoAmount;
+  reference: JudoReference;
+  cardAddress?: JudoAddress;
+  uiConfiguration?: JudoUIConfiguration;
+  paymentMethods?: JudoPaymentMethod;
+  supportedCardNetworks?: JudoCardNetwork;
+  primaryAccountDetails?: JudoAccountDetails;
+  applePayConfiguration?: JudoApplePayConfiguration;
+  googlePayConfiguration?: JudoGooglePayConfiguration;
+  isInitialRecurringPayment?: boolean;
+  networkTimeout?: NetworkTimeout;
+  challengeRequestIndicator?: ChallengeRequestIndicator;
+  scaExemption?: ScaExemption;
+  mobileNumber?: string;
+  phoneCountryCode?: string;
+  emailAddress?: string;
+  threeDSTwoMaxTimeout?: number;
+  threeDSTwoMessageVersion?: string;
+  isDelayedAuthorisation?: boolean;
+  recommendationConfiguration?: JudoRecommendationConfiguration;
+}
+
+export interface JudoRecommendationConfiguration {
+  url: string;
+  rsaPublicKey: string;
+  timeout?: number;
+}
+
+export enum ChallengeRequestIndicator {
+  NoPreference = 'noPreference',
+  NoChallenge = 'noChallenge',
+  ChallengePreferred = 'challengePreferred',
+  ChallengeAsMandate = 'challengeAsMandate',
+}
+
+export enum ScaExemption {
+  LowValue = 'lowValue',
+  SecureCorporate = 'secureCorporate',
+  TrustedBeneficiary = 'trustedBeneficiary',
+  TransactionRiskAnalysis = 'transactionRiskAnalysis',
+}
+
+export interface NetworkTimeout {
+  connectTimeout?: number;
+  readTimeout?: number;
+  writeTimeout?: number;
+}
+
+export enum JudoTransactionType {
+  Payment = 1,
+  PreAuth = 2,
+  RegisterCard = 3,
+  CheckCard = 4,
+  SaveCard = 5,
+  Unknown = -1,
+}
+
+export enum JudoTransactionMode {
+  Payment,
+  PreAuth,
+  ServerToServer,
+}
+
+export enum JudoTransactionResult {
+  Error,
+  Success,
+  Declined,
+  Unknown = -1,
+}
+
+export interface JudoAmount {
+  value: string;
+  currency: string;
+}
+
+export interface JudoReference {
+  consumerReference: string;
+  paymentReference?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface JudoAddress {
+  line1?: string;
+  line2?: string;
+  line3?: string;
+  postCode?: string;
+  town?: string;
+  countryCode?: number;
+  state?: string;
+}
+
+export interface JudoThreeDSToolbarCustomization {
+  backgroundColor?: string;
+  headerText?: string;
+  buttonText?: string;
+  textFontName?: string;
+  textColor?: string;
+  textFontSize?: number;
+}
+
+export interface JudoThreeDSLabelCustomization {
+  headingTextFontName?: string;
+  headingTextColor?: string;
+  headingTextFontSize?: number;
+  textFontName?: string;
+  textColor?: string;
+  textFontSize?: number;
+}
+
+export interface JudoThreeDSTextBoxCustomization {
+  borderWidth?: number;
+  borderColor?: string;
+  cornerRadius?: number;
+  textFontName?: string;
+  textColor?: string;
+  textFontSize?: number;
+}
+
+export enum JudoThreeDSButtonType {
+  SUBMIT = 'SUBMIT',
+  CONTINUE = 'CONTINUE',
+  NEXT = 'NEXT',
+  CANCEL = 'CANCEL',
+  RESEND = 'RESEND',
+}
+
+export interface JudoThreeDSButtonCustomization {
+  backgroundColor?: string;
+  cornerRadius?: number;
+  textFontName?: string;
+  textColor?: string;
+  textFontSize?: number;
+}
+
+export interface JudoThreeDSUIConfiguration {
+  buttonCustomizations?: Partial<
+    Record<JudoThreeDSButtonType, JudoThreeDSButtonCustomization>
+  >;
+  toolbarCustomization?: JudoThreeDSToolbarCustomization;
+  labelCustomization?: JudoThreeDSLabelCustomization;
+  textBoxCustomization?: JudoThreeDSTextBoxCustomization;
+}
+
+export interface JudoUIConfiguration {
+  isAVSEnabled?: boolean;
+  shouldPaymentMethodsDisplayAmount?: boolean;
+  shouldPaymentButtonDisplayAmount?: boolean;
+  /**
+   * @deprecated This export is deprecated. Please use `shouldAskForCSC` instead.
+   */
+  shouldPaymentMethodsVerifySecurityCode?: boolean;
+  shouldAskForBillingInformation?: boolean;
+  theme?: JudoTheme;
+  threeDSUIConfiguration?: JudoThreeDSUIConfiguration;
+  shouldAskForCSC?: boolean;
+  shouldAskForCardholderName?: boolean;
+}
+
+export interface JudoTheme {
+  largeTitleFont: string;
+  largeTitleSize: number;
+  titleFont: string;
+  titleSize: number;
+  headlineFont: string;
+  headlineSize: number;
+  headlineLightFont: string;
+  headlineLightSize: number;
+  bodyFont: string;
+  bodySize: number;
+  bodyBoldFont: string;
+  bodyBoldSize: number;
+  captionFont: string;
+  captionSize: number;
+  captionBoldFont: string;
+  captionBoldSize: number;
+  jpBlackColor: string;
+  jpDarkGrayColor: string;
+  jpGrayColor: string;
+  jpLightGrayColor: string;
+  jpRedColor: string;
+  jpWhiteColor: string;
+  buttonColor: string;
+  buttonTitleColor: string;
+  backButtonImage: string;
+  buttonCornerRadius: number;
+}
+
+export enum JudoPaymentMethod {
+  Card = 1 << 0,
+  ApplePay = 1 << 1,
+  GooglePay = 1 << 2,
+  iDEAL = 1 << 3,
+  All = 1 << 5,
+}
+
+export enum JudoCardNetwork {
+  Visa = 1 << 0,
+  Mastercard = 1 << 1,
+  Maestro = 1 << 2,
+  Amex = 1 << 3,
+  ChinaUnionPay = 1 << 4,
+  JCB = 1 << 5,
+  Discover = 1 << 6,
+  DinersClub = 1 << 7,
+  All = 1 << 8,
+}
+
+export interface JudoAccountDetails {
+  name?: string;
+  accountNumber?: string;
+  dateOfBirth?: string;
+  postCode?: string;
+}
+
+export interface JudoCardDetails {
+  cardLastFour?: string;
+  endDate?: string;
+  cardToken?: string;
+  cardNetwork?: JudoCardNetwork;
+  bank?: string;
+  cardCategory?: string;
+  cardCountry?: string;
+  cardFunding?: string;
+  cardScheme?: string;
+  cardHolderName?: string;
+}
+
+export interface JudoConsumer {
+  consumerReference?: string;
+  consumerToken?: string;
+}
+
+export interface JudoResponse {
+  receiptId?: string;
+  yourPaymentReference?: string;
+  type?: JudoTransactionType;
+  createdAt?: string;
+  result?: JudoTransactionResult;
+  message?: string;
+  judoId?: string;
+  merchantName?: string;
+  appearsOnStatementAs?: string;
+  originalAmount?: string;
+  netAmount?: string;
+  amount?: string;
+  currency?: string;
+  cardDetails?: JudoCardDetails;
+  consumerResponse?: JudoConsumer;
+}
+
+export interface JudoAuthorization {
+  token: string;
+  /**
+   * @deprecated This authentication method is deprecated, please use payment session instead.
+   */
+  secret?: string;
+  paymentSession?: string;
+}

package/src/types/judo-google-pay-configuration.ts

@@ -0,0 +1,47 @@
+export enum JudoGooglePayEnvironment {
+  TEST,
+  PRODUCTION,
+}
+
+export enum JudoAddressFormat {
+  MIN,
+  FULL,
+}
+
+export interface JudoBillingAddressParameters {
+  addressFormat: JudoAddressFormat;
+  isPhoneNumberRequired: boolean;
+}
+
+export interface JudoShippingAddressParameters {
+  allowedCountryCodes?: string[];
+  isPhoneNumberRequired: boolean;
+}
+
+export enum JudoGooglePayPriceStatus {
+  FINAL,
+  ESTIMATED,
+  NOT_CURRENTLY_KNOWN,
+}
+
+export enum JudoCheckoutOption {
+  DEFAULT,
+  COMPLETE_IMMEDIATE_PURCHASE,
+}
+
+export interface JudoGooglePayConfiguration {
+  environment: JudoGooglePayEnvironment;
+  merchantName?: string;
+  countryCode: string;
+  transactionId?: string;
+  totalPriceStatus: JudoGooglePayPriceStatus;
+  totalPriceLabel?: string;
+  checkoutOption?: JudoCheckoutOption;
+  isEmailRequired?: boolean;
+  isBillingAddressRequired: boolean;
+  billingAddressParameters?: JudoBillingAddressParameters;
+  isShippingAddressRequired: boolean;
+  shippingAddressParameters?: JudoShippingAddressParameters;
+  allowPrepaidCards?: boolean;
+  allowCreditCards?: boolean;
+}