@rnw-community/react-native-payments 0.83.1 → 1.2.0

package/src/class/payment-request/payment-request.ts

@@ -2,7 +2,7 @@
 import { Platform } from 'react-native';
 import uuid from 'react-native-uuid';
 
-import { emptyFn, getErrorMessage, isDefined, isNotEmptyArray, isNotEmptyString } from '@rnw-community/shared';
+import { emptyFn, isDefined, isNotEmptyArray, isNotEmptyString } from '@rnw-community/shared';
 
 import { AndroidPaymentMethodTokenizationType } from '../../@standard/android/enum/android-payment-method-tokenization-type.enum';
 import { defaultAndroidPaymentDataRequest } from '../../@standard/android/request/android-payment-data-request';
@@ -128,7 +128,7 @@ export class PaymentRequest {
         }
 
         await NativePayments.abort().catch(() => {
-            throw new DOMException(PaymentsErrorEnum.InvalidStateError);
+            throw new PaymentsError(`Failed aborting PaymentRequest`);
         });
 
         this.state = 'closed';
@@ -141,8 +141,9 @@ export class PaymentRequest {
             return Platform.OS === 'android'
                 ? new AndroidPaymentResponse(this.id, PaymentMethodNameEnum.AndroidPay, details)
                 : new IosPaymentResponse(this.id, PaymentMethodNameEnum.ApplePay, details);
-        } catch (e) {
-            throw new PaymentsError(`Failed creating AndroidPaymentResponse: ${getErrorMessage(e)}`);
+        } catch (_e) {
+            // TODO: Is there an standard exception for this?
+            throw new PaymentsError(`Failed parsing PaymentRequest details`);
         }
     }
 

package/src/class/payment-request/payment-request.web.ts

@@ -0,0 +1 @@
+export const { PaymentRequest } = typeof window === 'undefined' ? { PaymentRequest: null } : window;

package/src/class/payment-response/payment-response.spec.ts

@@ -0,0 +1,142 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+import { IosPKPaymentMethodType } from '../../@standard/ios/enum/ios-pk-payment-method-type.enum';
+import { PaymentComplete } from '../../enum/payment-complete.enum';
+import { NativePayments } from '../native-payments/native-payments';
+
+import { PaymentResponse } from './payment-response';
+
+import type { PaymentResponseDetailsInterface } from '../../interface/payment-response-details.interface';
+
+jest.mock('../native-payments/native-payments', () => ({
+    NativePayments: {
+        complete: jest.fn(),
+    },
+}));
+
+jest.mock('react-native', () => ({
+    Platform: {
+        OS: 'android',
+    },
+}));
+
+// eslint-disable-next-line max-lines-per-function
+describe('PaymentResponse', () => {
+    const mockDetails: PaymentResponseDetailsInterface = {
+        androidPayToken: {
+            cardInfo: {
+                assuranceDetails: {
+                    accountVerified: true,
+                    cardHolderAuthenticated: false,
+                },
+                cardDetails: '****1234',
+                cardNetwork: 'VISA',
+                billingAddress: {
+                    address1: '123 Test St',
+                    locality: 'Test City',
+                    administrativeArea: 'CA',
+                    sortingCode: '123',
+                    countryCode: 'US',
+                    name: 'Test Name',
+                    postalCode: '12345',
+                },
+            },
+            intermediateSigningKey: {
+                signedKey: {
+                    keyExpiration: '',
+                    keyValue: 'mockSignedKeyValue',
+                },
+                signatures: 'mockSignature1',
+            },
+            protocolVersion: 'EC_v1',
+            rawToken: 'mockRawToken',
+            signature: 'mockSignature',
+            signedMessage: {
+                encryptedMessage: 'mockEncryptedMessage',
+                ephemeralPublicKey: 'mockEphemeralKey',
+                tag: 'mockTag',
+            },
+        },
+        applePayToken: {
+            paymentData: {
+                version: 'EC_v1',
+                data: 'mockData',
+                signature: 'mockSignature',
+                header: {
+                    ephemeralPublicKey: 'mockEphemeralPublicKey',
+                    publicKeyHash: 'mockPublicKeyHash',
+                    transactionId: 'mockTransactionId',
+                    wrappedKey: 'mockWrappedKey',
+                },
+            },
+            paymentMethod: {
+                displayName: 'Test Card',
+                network: 'Visa',
+                type: IosPKPaymentMethodType.PKPaymentMethodTypeCredit,
+            },
+            transactionIdentifier: 'testTransactionId',
+        },
+    };
+
+    // eslint-disable-next-line jest/no-hooks
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('constructor', () => {
+        it('should correctly initialize properties', () => {
+            expect.assertions(3);
+
+            const paymentResponse = new PaymentResponse('testRequestId', 'testMethodName', mockDetails);
+
+            expect(paymentResponse.requestId).toBe('testRequestId');
+            expect(paymentResponse.methodName).toBe('testMethodName');
+            expect(paymentResponse.details).toBe(mockDetails);
+        });
+    });
+
+    describe('complete', () => {
+        it('should call NativePayments.complete with the correct result', async () => {
+            expect.assertions(1);
+
+            const paymentResponse = new PaymentResponse('testRequestId', 'testMethodName', mockDetails);
+
+            jest.mocked(NativePayments.complete).mockResolvedValueOnce(undefined);
+            await paymentResponse.complete(PaymentComplete.SUCCESS);
+
+            expect(NativePayments.complete).toHaveBeenCalledWith(PaymentComplete.SUCCESS);
+        });
+
+        it('should throw an error if complete is called more than once', async () => {
+            expect.assertions(1);
+
+            const paymentResponse = new PaymentResponse('testRequestId', 'testMethodName', mockDetails);
+
+            jest.mocked(NativePayments.complete).mockResolvedValueOnce(undefined);
+            await paymentResponse.complete(PaymentComplete.SUCCESS);
+
+            await expect(paymentResponse.complete(PaymentComplete.SUCCESS)).rejects.toThrow(new Error('InvalidStateError'));
+        });
+    });
+
+    describe('retry', () => {
+        it('should resolve with undefined when called', async () => {
+            expect.assertions(1);
+
+            const paymentResponse = new PaymentResponse('testRequestId', 'testMethodName', mockDetails);
+
+            await expect(paymentResponse.retry()).resolves.toBeUndefined();
+        });
+
+        it('should throw an error if retry is called after complete', async () => {
+            expect.assertions(1);
+
+            const paymentResponse = new PaymentResponse('testRequestId', 'testMethodName', mockDetails);
+
+            jest.mocked(NativePayments.complete).mockResolvedValueOnce(undefined);
+            await paymentResponse.complete(PaymentComplete.SUCCESS);
+
+            await expect(paymentResponse.retry()).rejects.toThrow('InvalidStateError');
+        });
+    });
+});

package/src/class/payment-response/payment-response.ts

@@ -20,7 +20,7 @@ export class PaymentResponse {
     ) {}
 
     // https://www.w3.org/TR/payment-request/#complete-method
-    complete(result: PaymentComplete): Promise<void> {
+    async complete(result: PaymentComplete): Promise<void> {
         if (this.completeCalled) {
             throw new Error('InvalidStateError');
         }
@@ -33,13 +33,14 @@ export class PaymentResponse {
     }
 
     // https://www.w3.org/TR/payment-request/#dom-paymentresponse-retry
-    retry(_errorFields?: PaymentValidationErrors): Promise<undefined> {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async retry(_errorFields?: PaymentValidationErrors): Promise<undefined> {
         if (this.completeCalled) {
             throw new Error('InvalidStateError');
         }
 
         // TODO: Implement logic https://www.w3.org/TR/payment-request/#retry-method
 
-        return Promise.resolve(undefined);
+        return undefined;
     }
 }

package/src/class/payment-response/payment-response.web.ts

@@ -0,0 +1 @@
+export const { PaymentResponse } = typeof window === 'undefined' ? { PaymentResponse: null } : window;

package/src/expo-plugins/plugin.props.ts

@@ -0,0 +1,3 @@
+export interface ReactNativePaymentsPluginProps {
+    merchantIdentifier: string;
+}

package/src/expo-plugins/with-apple-pay.ts

@@ -0,0 +1,27 @@
+import { withEntitlementsPlist } from 'expo/config-plugins';
+
+import { isDefined } from '@rnw-community/shared';
+
+import type { ReactNativePaymentsPluginProps } from './plugin.props';
+import type { ConfigPlugin } from 'expo/config-plugins';
+
+export const withApplePay: ConfigPlugin<ReactNativePaymentsPluginProps> = (initialConfig, { merchantIdentifier }) => {
+    if (!isDefined(merchantIdentifier)) {
+        throw new Error(`Pleas provide "@rnw-community/react-native-payments" plugin option "merchantIdentifier"`);
+    }
+
+    return withEntitlementsPlist(initialConfig, configWithEntitlements => {
+        if (merchantIdentifier) {
+            if (!isDefined(configWithEntitlements.modResults['com.apple.developer.in-app-payments'])) {
+                configWithEntitlements.modResults['com.apple.developer.in-app-payments'] = [];
+            }
+
+            const applePayArray = configWithEntitlements.modResults['com.apple.developer.in-app-payments'] as string[];
+            if (!applePayArray.includes(merchantIdentifier)) {
+                applePayArray.push(merchantIdentifier);
+            }
+        }
+
+        return configWithEntitlements;
+    });
+};

package/src/expo-plugins/with-google-pay.ts

@@ -0,0 +1,31 @@
+import { withAndroidManifest } from '@expo/config-plugins';
+
+import type { ReactNativePaymentsPluginProps } from './plugin.props';
+import type { ConfigPlugin } from '@expo/config-plugins';
+
+export const withGooglePay: ConfigPlugin<ReactNativePaymentsPluginProps> = initialConfig =>
+    withAndroidManifest(initialConfig, config => {
+        const androidManifest = config.modResults;
+        const mainApplication = androidManifest.manifest.application?.[0];
+
+        if (mainApplication) {
+            const existingMetaData = mainApplication['meta-data']?.find(
+                metadata => metadata.$['android:name'] === 'com.google.android.gms.wallet.api.enabled'
+            );
+
+            if (!existingMetaData) {
+                if (!mainApplication['meta-data']) {
+                    mainApplication['meta-data'] = [];
+                }
+                mainApplication['meta-data'].push({
+                    // eslint-disable-next-line id-length
+                    $: {
+                        'android:name': 'com.google.android.gms.wallet.api.enabled',
+                        'android:value': 'true',
+                    },
+                });
+            }
+        }
+
+        return config;
+    });

package/src/expo-plugins/with-payments.ts

@@ -0,0 +1,13 @@
+import { withPlugins } from '@expo/config-plugins';
+
+import { withApplePay } from './with-apple-pay';
+import { withGooglePay } from './with-google-pay';
+
+import type { ReactNativePaymentsPluginProps } from './plugin.props';
+import type { ConfigPlugin } from '@expo/config-plugins';
+
+export const withPayments: ConfigPlugin<ReactNativePaymentsPluginProps> = (config, props) =>
+    withPlugins(config, [
+        [withApplePay, props],
+        [withGooglePay, props],
+    ]);

package/src/util/is-valid-decimal-monetary-value.util.ts

@@ -1,4 +1,4 @@
-import isDecimal from 'validator/es/lib/isDecimal';
+import validator from 'validator';
 
 import { isNumber, isString } from '@rnw-community/shared';
 
@@ -9,7 +9,7 @@ const isValidStringAmount = (stringAmount: string): boolean => {
         return false;
     }
 
-    return isDecimal(stringAmount);
+    return validator.isDecimal(stringAmount);
 };
 
 export const isValidDecimalMonetaryValue = (amountValue: AmountValue): boolean => {

package/src/util/validate-payment-methods.util.ts

@@ -1,4 +1,4 @@
-import { isDefined } from '@rnw-community/shared';
+import { isDefined, isNotEmptyArray } from '@rnw-community/shared';
 
 import { ConstructorError } from '../error/constructor.error';
 
@@ -7,7 +7,7 @@ import type { PaymentMethodData } from '../@standard/w3c/payment-method-data';
 /** @deprecated Move to PaymentRequest */
 export const validatePaymentMethods = (methodData: PaymentMethodData[]): void => {
     // Check that at least one payment method is passed in
-    if (methodData.length < 1) {
+    if (!isNotEmptyArray(methodData)) {
         throw new ConstructorError(`At least one payment method is required`);
     }
 

package/app.plugin.js

@@ -1 +0,0 @@
-module.exports = require('./plugins/with-payments');

package/plugins/with-apple-pay.js

@@ -1,24 +0,0 @@
-const { withDangerousMod } = require("@expo/config-plugins");
-const fs = require("fs");
-const path = require("path");
-
-const withApplePay = (config) =>
-  withDangerousMod(config, [
-    "ios",
-    async (config) => {
-      const filePath = path.join(
-        config.modRequest.platformProjectRoot,
-        config.modRequest.projectName,
-        "AppDelegate.h"
-      );
-
-      const content = fs.readFileSync(filePath, "utf-8");
-      if (!content.includes("#import <PassKit/PassKit.h>")) {
-        fs.writeFileSync(filePath, `#import <PassKit/PassKit.h>\n${content}`);
-      }
-
-      return config;
-    },
-  ]);
-
-module.exports = { withApplePay };

package/plugins/with-google-pay.js

@@ -1,49 +0,0 @@
-const { withAppBuildGradle, withAndroidManifest } = require("@expo/config-plugins");
-
-const withGooglePay = (config) => {
-  // Add Google Pay dependency to app/build.gradle
-  config = withAppBuildGradle(config, (config) => {
-    if (config.modResults.language === "groovy") {
-      config.modResults.contents = config.modResults.contents.replace(
-        /dependencies\s?{/,
-        `dependencies {
-    implementation 'com.google.android.gms:play-services-wallet:19.2.0'`,
-      );
-    } else {
-      throw new Error(
-        "Unable to add Google Pay dependency to build.gradle: Kotlin build files are not supported."
-      );
-    }
-    return config;
-  });
-
-  // Add meta-data to AndroidManifest.xml
-  config = withAndroidManifest(config, async (config) => {
-    const androidManifest = config.modResults;
-    const mainApplication = androidManifest.manifest.application[0];
-
-    // Check if the meta-data already exists
-    const existingMetaData = mainApplication["meta-data"]?.find(
-      (metadata) => metadata.$["android:name"] === "com.google.android.gms.wallet.api.enabled"
-    );
-
-    if (!existingMetaData) {
-      // Add the new meta-data
-      if (!mainApplication["meta-data"]) {
-        mainApplication["meta-data"] = [];
-      }
-      mainApplication["meta-data"].push({
-        $: {
-          "android:name": "com.google.android.gms.wallet.api.enabled",
-          "android:value": "true",
-        },
-      });
-    }
-
-    return config;
-  });
-
-  return config;
-};
-
-module.exports = { withGooglePay };

package/plugins/with-payments.js

@@ -1,12 +0,0 @@
-const { withPlugins } = require('@expo/config-plugins');
-const { withApplePay } = require('./with-apple-pay');
-const { withGooglePay } = require('./with-google-pay');
-
-const withPayments = (config) => {
-  return withPlugins(config, [
-    withApplePay,
-    withGooglePay
-  ]);
-};
-
-module.exports = withPayments;