tf-checkout-react-native 2.0.0-beta.0 → 2.0.0-beta.11

package/src/confirmer.ts

@@ -10,11 +10,8 @@
  * flows from the mounted `<CardInput/>` (`<CardField/>`) into `confirmPayment`
  * natively — there is no element to register the way web does.
  *
- * Deferred (optional ports, left unimplemented — the engine falls back to a
- * typed "unsupported gateway" for them): WebView-based rails — Razorpay / PayPal
- * / Stripe redirect methods (`providerPage`, `createRedirectPaymentMethod`) and
- * Xendit tokenization (`tokenizeXenditCard`). They need `react-native-webview`,
- * which this package injects rather than depends on; wiring them is a follow-up.
+ * CheckoutProvider owns provider-page windows for PayPal, Razorpay, Xendit and
+ * Stripe redirect rails. Imperative hosts supply their own providerPage port.
  */
 import { Linking } from 'react-native'
 import {
@@ -29,10 +26,14 @@ import {
   type BillingDetails,
 } from '@stripe/stripe-react-native'
 
-import type {
-  CheckoutBilling,
-  CheckoutPorts,
-  PaymentConfirmer,
+import {
+  nativeStripeErrorOutcome,
+  confirmedStripeIntentStatus,
+  paymentProviderError,
+  type CheckoutBilling,
+  type CheckoutPorts,
+  type NativeStripeErrorLike,
+  type PaymentConfirmer,
 } from 'tf-checkout-shared'
 
 /** `CheckoutBilling` → the native SDK's `BillingDetails`. Mirrors the web
@@ -55,6 +56,18 @@ const toBillingDetails = (billing: CheckoutBilling): BillingDetails => ({
 const failed = (message: string | undefined, fallback: string): Error =>
   new Error(message || fallback)
 
+/** A stripe-react-native error as the error the engine classifies: only an
+ *  explicit decline or cancel lets the checkout reset
+ *  (`nativeStripeErrorOutcome`). */
+const stripeFailure = (
+  error: NativeStripeErrorLike & { message?: string },
+  fallback: string
+): Error =>
+  paymentProviderError(error.message || fallback, nativeStripeErrorOutcome(error), {
+    type: error.type,
+    code: error.stripeErrorCode ?? error.code,
+  })
+
 /**
  * The confirmer every `useCheckout`/`<CardInput/>` binds to. `init()` is
  * idempotent per key so an event on a connected Stripe account re-initializes
@@ -62,6 +75,8 @@ const failed = (message: string | undefined, fallback: string): Error =>
  */
 export const createRnStripeConfirmer = (): PaymentConfirmer => {
   let initKey: string | null = null
+  let accountKey: string | null = null
+  const listeners = new Set<() => void>()
 
   return {
     init: async ({ publishableKey, accountId, merchantIdentifier, urlScheme }) => {
@@ -74,6 +89,18 @@ export const createRnStripeConfirmer = (): PaymentConfirmer => {
         ...(urlScheme ? { urlScheme } : {}),
       })
       initKey = key
+      accountKey = `${publishableKey}:${accountId ?? ''}`
+      listeners.forEach((listener) => listener())
+    },
+
+    // `publishableKey:accountId`, the shape `bundleConfirmerKey` expects.
+    currentKey: () => accountKey,
+
+    subscribe: (listener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
     },
 
     // Native statuses are already the port's PascalCase vocabulary — no normalize.
@@ -87,8 +114,8 @@ export const createRnStripeConfirmer = (): PaymentConfirmer => {
         paymentMethodType: 'Card',
         paymentMethodData: { billingDetails: toBillingDetails(billing) },
       })
-      if (error) throw failed(error.message, 'Payment failed.')
-      return paymentIntent?.status
+      if (error) throw stripeFailure(error, 'Payment failed.')
+      return confirmedStripeIntentStatus(paymentIntent)
     },
 
     confirmApplePay: async (clientSecret, total, currencyCode, merchant) => {
@@ -105,8 +132,8 @@ export const createRnStripeConfirmer = (): PaymentConfirmer => {
           ],
         },
       })
-      if (error) throw failed(error.message, 'Apple Pay failed.')
-      return paymentIntent?.status
+      if (error) throw stripeFailure(error, 'Apple Pay failed.')
+      return confirmedStripeIntentStatus(paymentIntent)
     },
 
     confirmGooglePay: async (clientSecret, total, currencyCode, merchant) => {
@@ -118,8 +145,8 @@ export const createRnStripeConfirmer = (): PaymentConfirmer => {
           merchantName: merchant.merchantName ?? 'Order',
         },
       })
-      if (error) throw failed(error.message, 'Google Pay failed.')
-      return paymentIntent?.status
+      if (error) throw stripeFailure(error, 'Google Pay failed.')
+      return confirmedStripeIntentStatus(paymentIntent)
     },
   }
 }
@@ -130,9 +157,9 @@ export const createRnStripeConfirmer = (): PaymentConfirmer => {
  * `Linking`. WebView rails are intentionally absent (see file header).
  */
 export const createRnPorts = (): Omit<CheckoutPorts, 'confirmer'> => ({
-  openUrl: (url: string) => {
-    void Linking.openURL(url)
-  },
+  // The promise is handed back: a URL the device cannot open rejects, and the
+  // caller shows its failure (for example "We could not open the payment page").
+  openUrl: (url: string) => Linking.openURL(url).then(() => undefined),
 
   createCardPaymentMethod: async (billing) => {
     const { paymentMethod, error } = await createPaymentMethod({
@@ -143,9 +170,74 @@ export const createRnPorts = (): Omit<CheckoutPorts, 'confirmer'> => ({
     return paymentMethod.id
   },
 
+  createRedirectPaymentMethod: async (methodType, billing) => {
+    const details = toBillingDetails(billing)
+    const result = await (() => {
+      switch (methodType) {
+        case 'klarna':
+          return createPaymentMethod({
+            paymentMethodType: 'Klarna',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'afterpay_clearpay':
+          return createPaymentMethod({
+            paymentMethodType: 'AfterpayClearpay',
+            paymentMethodData: { billingDetails: details, shippingDetails: details },
+          })
+        case 'affirm':
+          return createPaymentMethod({
+            paymentMethodType: 'Affirm',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'ideal':
+          return createPaymentMethod({
+            paymentMethodType: 'Ideal',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'bancontact':
+          return createPaymentMethod({
+            paymentMethodType: 'Bancontact',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'eps':
+          return createPaymentMethod({
+            paymentMethodType: 'Eps',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'p24':
+          return createPaymentMethod({
+            paymentMethodType: 'P24',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'alipay':
+          return createPaymentMethod({ paymentMethodType: 'Alipay' })
+        case 'grabpay':
+          return createPaymentMethod({
+            paymentMethodType: 'GrabPay',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'cashapp':
+          return createPaymentMethod({
+            paymentMethodType: 'CashApp',
+            paymentMethodData: { billingDetails: details },
+          })
+        case 'paypal':
+          return createPaymentMethod({
+            paymentMethodType: 'PayPal',
+            paymentMethodData: { billingDetails: details },
+          })
+        default:
+          throw new Error('This payment method is not available on this device.')
+      }
+    })()
+    if (result.error || !result.paymentMethod?.id)
+      throw failed(result.error?.message, 'Unable to start this payment method.')
+    return result.paymentMethod.id
+  },
+
   handleNextAction: async (clientSecret) => {
     const { error } = await handleNextAction(clientSecret)
-    if (error) throw failed(error.message, 'Payment failed')
+    if (error) throw stripeFailure(error, 'Payment failed')
   },
 
   confirmOxxo: async (clientSecret, billing) => {
@@ -175,6 +267,6 @@ export const createRnPorts = (): Omit<CheckoutPorts, 'confirmer'> => ({
       paymentMethodType: 'Card',
       paymentMethodData: { paymentMethodId },
     })
-    if (error) throw failed(error.message, 'Payment failed')
+    if (error) throw stripeFailure(error, 'Payment failed')
   },
 })