tf-checkout-react-native 1.0.47 → 2.0.0-beta.5

package/src/confirmer.ts

@@ -0,0 +1,272 @@
+/**
+ * React Native adapter of the SDK's `PaymentConfirmer` + `CheckoutPorts` — the
+ * native mirror of the web `confirmer.ts`. It binds `@stripe/stripe-react-native`
+ * so the engine in `tf-checkout-shared` runs the exact same
+ * cart → order → charge → finalize sequence the web runs, with the same
+ * retry-safety invariants and duplicate-charge guards.
+ *
+ * Uses the IMPERATIVE stripe-react-native functions (not the `useConfirmPayment`
+ * hook) because the confirmer is a module singleton, not a component. Card data
+ * flows from the mounted `<CardInput/>` (`<CardField/>`) into `confirmPayment`
+ * natively — there is no element to register the way web does.
+ *
+ * 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 {
+  confirmPayment,
+  confirmPlatformPayPayment,
+  confirmSetupIntent,
+  createPaymentMethod,
+  handleNextAction,
+  initStripe,
+  PlatformPay,
+  retrievePaymentIntent,
+  type BillingDetails,
+} from '@stripe/stripe-react-native'
+
+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
+ *  `stripeBillingDetails`; the SDK collects card data from `<CardField/>`. */
+const toBillingDetails = (billing: CheckoutBilling): BillingDetails => ({
+  email: billing.email,
+  name: `${billing.firstName} ${billing.lastName}`.trim(),
+  phone: billing.phone || undefined,
+  address: {
+    line1: billing.streetAddress || undefined,
+    city: billing.city || undefined,
+    postalCode: billing.zip || undefined,
+    // Stripe wants ISO-2; CheckoutBilling carries it when the consumer resolved
+    // it (backend ids are numeric). Left undefined otherwise.
+    country: billing.countryCode || undefined,
+    state: billing.stateCode || undefined,
+  },
+})
+
+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
+ * only when the key/account actually changes.
+ */
+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 }) => {
+      const key = `${publishableKey}:${accountId ?? ''}:${merchantIdentifier ?? ''}`
+      if (initKey === key) return
+      await initStripe({
+        publishableKey,
+        ...(accountId ? { stripeAccountId: accountId } : {}),
+        ...(merchantIdentifier ? { merchantIdentifier } : {}),
+        ...(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.
+    getIntentStatus: async (clientSecret) => {
+      const { paymentIntent } = await retrievePaymentIntent(clientSecret)
+      return paymentIntent?.status
+    },
+
+    confirmCard: async (clientSecret, billing) => {
+      const { error, paymentIntent } = await confirmPayment(clientSecret, {
+        paymentMethodType: 'Card',
+        paymentMethodData: { billingDetails: toBillingDetails(billing) },
+      })
+      if (error) throw stripeFailure(error, 'Payment failed.')
+      return confirmedStripeIntentStatus(paymentIntent)
+    },
+
+    confirmApplePay: async (clientSecret, total, currencyCode, merchant) => {
+      const { error, paymentIntent } = await confirmPlatformPayPayment(clientSecret, {
+        applePay: {
+          merchantCountryCode: merchant.merchantCountryCode ?? 'US',
+          currencyCode,
+          cartItems: [
+            {
+              label: merchant.merchantName ?? 'Order',
+              amount: total,
+              paymentType: PlatformPay.PaymentType.Immediate,
+            },
+          ],
+        },
+      })
+      if (error) throw stripeFailure(error, 'Apple Pay failed.')
+      return confirmedStripeIntentStatus(paymentIntent)
+    },
+
+    confirmGooglePay: async (clientSecret, total, currencyCode, merchant) => {
+      const { error, paymentIntent } = await confirmPlatformPayPayment(clientSecret, {
+        googlePay: {
+          testEnv: merchant.testEnv === true,
+          merchantCountryCode: merchant.merchantCountryCode ?? 'US',
+          currencyCode,
+          merchantName: merchant.merchantName ?? 'Order',
+        },
+      })
+      if (error) throw stripeFailure(error, 'Google Pay failed.')
+      return confirmedStripeIntentStatus(paymentIntent)
+    },
+  }
+}
+
+/**
+ * The native ports the alternative Stripe rails run on. OXXO / MSI / payment-plan
+ * legs bind the same imperative stripe-react-native functions; `openUrl` uses
+ * `Linking`. WebView rails are intentionally absent (see file header).
+ */
+export const createRnPorts = (): Omit<CheckoutPorts, 'confirmer'> => ({
+  // 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({
+      paymentMethodType: 'Card',
+      paymentMethodData: { billingDetails: toBillingDetails(billing) },
+    })
+    if (error || !paymentMethod?.id) throw failed(error?.message, 'Payment failed')
+    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 stripeFailure(error, 'Payment failed')
+  },
+
+  confirmOxxo: async (clientSecret, billing) => {
+    const { error, paymentIntent } = await confirmPayment(clientSecret, {
+      paymentMethodType: 'Oxxo',
+      paymentMethodData: { billingDetails: toBillingDetails(billing) },
+    })
+    return { error: error?.message, nextAction: paymentIntent?.nextAction as unknown }
+  },
+
+  // Payment plan (new card): confirm the SetupIntent to SAVE the card (nothing
+  // charged) and return its PaymentMethod id for the server-side plan.
+  confirmPaymentPlanSetup: async (clientSecret, billing) => {
+    const { setupIntent, error } = await confirmSetupIntent(clientSecret, {
+      paymentMethodType: 'Card',
+      paymentMethodData: { billingDetails: toBillingDetails(billing) },
+    })
+    const paymentMethodId = setupIntent?.paymentMethod?.id
+    if (error || !paymentMethodId) throw failed(error?.message, 'Card setup failed')
+    return paymentMethodId
+  },
+
+  // Payment plan (saved-card 3DS): confirm the pending charge against the
+  // existing PaymentMethod when the plan comes back requires_action.
+  confirmSavedCardPayment: async (clientSecret, paymentMethodId) => {
+    const { error } = await confirmPayment(clientSecret, {
+      paymentMethodType: 'Card',
+      paymentMethodData: { paymentMethodId },
+    })
+    if (error) throw stripeFailure(error, 'Payment failed')
+  },
+})