feat: add Airwallex payments and multi-currency support

frontend/src/components/payment/__tests__/PaymentProviderDialog.spec.ts

@@ -2,34 +2,66 @@ import { describe, expect, it, vi } from 'vitest'
 import { mount } from '@vue/test-utils'
 import { nextTick } from 'vue'
 import PaymentProviderDialog from '@/components/payment/PaymentProviderDialog.vue'
+import { STRIPE_SDK_API_VERSION } from '@/components/payment/providerConfig'
+import type { ProviderInstance } from '@/types/payment'
 
 const messages: Record<string, string> = {
   'admin.settings.payment.providerConfig': 'Credentials',
   'admin.settings.payment.paymentGuideTrigger': 'View payment guide',
   'admin.settings.payment.alipayGuideSummary': 'Desktop prefers QR precreate and falls back to cashier; mobile prefers WAP checkout.',
   'admin.settings.payment.wxpayGuideSummary': 'Desktop prefers Native QR; mobile routes to JSAPI or H5 based on browser context.',
+  'admin.settings.payment.airwallexGuideSummary': 'Use Payment Acceptance read/write only.',
+  'admin.settings.payment.stripeWebhookHint': 'Configure Stripe webhook.',
+  'admin.settings.payment.stripeWebhookApiVersionHint': 'Use Stripe API version {version}.',
+  'admin.settings.payment.airwallexWebhookHint': 'Select payment_intent.succeeded and use the latest stable API version.',
 }
 
 vi.mock('vue-i18n', () => ({
   useI18n: () => ({
-    t: (key: string) => messages[key] ?? key,
+    t: (key: string, params?: Record<string, string>) => {
+      const message = messages[key] ?? key
+      if (!params) return message
+      return Object.entries(params).reduce(
+        (value, [name, replacement]) => value.replaceAll(`{${name}}`, replacement),
+        message,
+      )
+    },
   }),
 }))
 
-function mountDialog() {
+function providerFactory(overrides: Partial<ProviderInstance> = {}): ProviderInstance {
+  return {
+    id: 1,
+    provider_key: 'airwallex',
+    name: 'Airwallex',
+    config: {},
+    supported_types: ['airwallex'],
+    enabled: true,
+    payment_mode: '',
+    refund_enabled: false,
+    allow_user_refund: false,
+    limits: '',
+    sort_order: 0,
+    ...overrides,
+  }
+}
+
+function mountDialog(options: { editing?: ProviderInstance | null } = {}) {
   return mount(PaymentProviderDialog, {
     props: {
       show: true,
       saving: false,
-      editing: null,
+      editing: options.editing ?? null,
       allKeyOptions: [
         { value: 'alipay', label: 'Alipay' },
         { value: 'wxpay', label: 'WeChat Pay' },
         { value: 'stripe', label: 'Stripe' },
+        { value: 'airwallex', label: 'Airwallex' },
       ],
       enabledKeyOptions: [
         { value: 'alipay', label: 'Alipay' },
         { value: 'wxpay', label: 'WeChat Pay' },
+        { value: 'airwallex', label: 'Airwallex' },
       ],
       allPaymentTypes: [
         { value: 'alipay', label: 'Alipay' },
@@ -66,6 +98,7 @@ describe('PaymentProviderDialog payment guide', () => {
   it.each([
     ['alipay', 'admin.settings.payment.alipayGuideSummary'],
     ['wxpay', 'admin.settings.payment.wxpayGuideSummary'],
+    ['airwallex', 'admin.settings.payment.airwallexGuideSummary'],
   ])('shows the payment guide summary for %s', async (providerKey, summaryKey) => {
     const wrapper = mountDialog()
 
@@ -75,4 +108,52 @@ describe('PaymentProviderDialog payment guide', () => {
     expect(wrapper.text()).toContain(messages[summaryKey])
     expect(wrapper.find('button[title="View payment guide"]').exists()).toBe(true)
   })
+
+  it('shows Airwallex webhook event and API version guidance with the webhook URL', async () => {
+    const wrapper = mountDialog()
+
+    ;(wrapper.vm as unknown as { reset: (key: string) => void }).reset('airwallex')
+    await nextTick()
+
+    expect(wrapper.text()).toContain(messages['admin.settings.payment.airwallexWebhookHint'])
+    expect(wrapper.text()).toContain('/api/v1/payment/webhook/airwallex')
+  })
+
+  it('shows Stripe webhook API version guidance with the integrated SDK version', async () => {
+    const wrapper = mountDialog()
+
+    ;(wrapper.vm as unknown as { reset: (key: string) => void }).reset('stripe')
+    await nextTick()
+
+    expect(wrapper.text()).toContain(messages['admin.settings.payment.stripeWebhookHint'])
+    expect(wrapper.text()).toContain(`Use Stripe API version ${STRIPE_SDK_API_VERSION}.`)
+    expect(wrapper.text()).toContain('/api/v1/payment/webhook/stripe')
+  })
+
+  it('emits an empty Airwallex accountId when the admin clears it', async () => {
+    const provider = providerFactory({
+      config: {
+        clientId: 'cid_123',
+        apiBase: 'https://api.airwallex.com/api/v1',
+        countryCode: 'CN',
+        currency: 'CNY',
+        accountId: 'acct_123',
+      },
+    })
+    const wrapper = mountDialog({ editing: provider })
+
+    ;(wrapper.vm as unknown as { loadProvider: (provider: ProviderInstance) => void }).loadProvider(provider)
+    await nextTick()
+
+    const accountIdInput = wrapper
+      .findAll('input[type="text"]')
+      .find(input => (input.element as HTMLInputElement).value === 'acct_123')
+    if (!accountIdInput) throw new Error('accountId input not found')
+
+    await accountIdInput.setValue('')
+    await wrapper.find('form').trigger('submit.prevent')
+
+    const payload = wrapper.emitted('save')?.[0]?.[0] as { config: Record<string, string> }
+    expect(payload.config.accountId).toBe('')
+  })
 })

frontend/src/components/payment/__tests__/currency.spec.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest'
+import { formatPaymentAmount } from '../currency'
+
+describe('formatPaymentAmount', () => {
+  it('uses the currency default fraction digits', () => {
+    expect(formatPaymentAmount(100, 'JPY', 'en-US')).not.toContain('.00')
+    expect(formatPaymentAmount(100, 'KRW', 'en-US')).not.toContain('.00')
+    expect(formatPaymentAmount(100, 'HKD', 'en-US')).toContain('.00')
+  })
+})

frontend/src/components/payment/__tests__/paymentFlow.spec.ts

@@ -38,12 +38,14 @@ describe('getVisibleMethods', () => {
       alipay_direct: methodLimit({ single_min: 5 }),
       wxpay: methodLimit({ single_max: 100 }),
       stripe: methodLimit({ fee_rate: 3 }),
+      airwallex: methodLimit({ single_min: 10 }),
     })
 
     expect(visible).toEqual({
       alipay: methodLimit({ single_min: 5 }),
       wxpay: methodLimit({ single_max: 100 }),
       stripe: methodLimit({ fee_rate: 3 }),
+      airwallex: methodLimit({ single_min: 10 }),
     })
   })
 
@@ -104,6 +106,29 @@ describe('decidePaymentLaunch', () => {
     expect(decision.paymentState.orderType).toBe('subscription')
   })
 
+  it('routes Airwallex client secrets through the hosted Airwallex page', () => {
+    const decision = decidePaymentLaunch(createOrderResult({
+      client_secret: 'awx_cs',
+      intent_id: 'int_awx',
+      currency: 'CNY',
+      country_code: 'CN',
+      payment_env: 'demo',
+      out_trade_no: 'sub2_awx',
+    }), {
+      visibleMethod: 'airwallex',
+      orderType: 'balance',
+      isMobile: false,
+      airwallexRouteUrl: '/payment/airwallex?order_id=101',
+    })
+
+    expect(decision.kind).toBe('airwallex_route')
+    expect(decision.paymentState.payUrl).toBe('/payment/airwallex?order_id=101')
+    expect(decision.paymentState.intentId).toBe('int_awx')
+    expect(decision.paymentState.currency).toBe('CNY')
+    expect(decision.paymentState.countryCode).toBe('CN')
+    expect(decision.paymentState.paymentEnv).toBe('demo')
+  })
+
   it('keeps hosted redirect metadata for recovery flows', () => {
     const decision = decidePaymentLaunch(createOrderResult({
       pay_url: 'https://pay.example.com/session/abc',
@@ -248,6 +273,10 @@ describe('readPaymentRecoverySnapshot', () => {
       payUrl: 'https://pay.example.com/session/33',
       outTradeNo: 'sub2_33',
       clientSecret: '',
+      intentId: '',
+      currency: '',
+      countryCode: '',
+      paymentEnv: '',
       payAmount: 18,
       orderType: 'balance',
       paymentMode: 'popup',
@@ -273,6 +302,10 @@ describe('readPaymentRecoverySnapshot', () => {
       payUrl: 'https://pay.example.com/session/55',
       outTradeNo: 'sub2_55',
       clientSecret: '',
+      intentId: '',
+      currency: '',
+      countryCode: '',
+      paymentEnv: '',
       payAmount: 18,
       orderType: 'balance',
       paymentMode: 'popup',
@@ -317,4 +350,31 @@ describe('readPaymentRecoverySnapshot', () => {
     expect(restored?.orderId).toBe(44)
     expect(restored?.outTradeNo).toBe('')
   })
+
+  it('keeps backward compatibility with snapshots written before Airwallex fields existed', () => {
+    const restored = readPaymentRecoverySnapshot(JSON.stringify({
+      orderId: 45,
+      amount: 28,
+      qrCode: '',
+      expiresAt: '2099-01-01T00:10:00.000Z',
+      paymentType: 'airwallex',
+      payUrl: '/payment/airwallex?order_id=45',
+      outTradeNo: 'sub2_45',
+      clientSecret: 'awx_cs',
+      payAmount: 28,
+      orderType: 'balance',
+      paymentMode: '',
+      resumeToken: 'resume-45',
+      createdAt: Date.UTC(2099, 0, 1, 0, 0, 0),
+    }), {
+      now: Date.UTC(2099, 0, 1, 0, 1, 0),
+      resumeToken: 'resume-45',
+    })
+
+    expect(restored?.orderId).toBe(45)
+    expect(restored?.intentId).toBe('')
+    expect(restored?.currency).toBe('')
+    expect(restored?.countryCode).toBe('')
+    expect(restored?.paymentEnv).toBe('')
+  })
 })

frontend/src/components/payment/__tests__/providerConfig.spec.ts

@@ -1,20 +1,52 @@
 import { describe, expect, it } from 'vitest'
-import { PROVIDER_CONFIG_FIELDS } from '@/components/payment/providerConfig'
+import { PAYMENT_CURRENCY_OPTIONS, PROVIDER_CONFIG_FIELDS } from '@/components/payment/providerConfig'
 
-function findField(key: string) {
-  const fields = PROVIDER_CONFIG_FIELDS.wxpay || []
+function findField(providerKey: string, key: string) {
+  const fields = PROVIDER_CONFIG_FIELDS[providerKey] || []
   return fields.find(field => field.key === key)
 }
 
 describe('PROVIDER_CONFIG_FIELDS.wxpay', () => {
   it('keeps admin form validation aligned with backend-required credentials', () => {
-    expect(findField('publicKeyId')?.optional).toBeFalsy()
-    expect(findField('certSerial')?.optional).toBeFalsy()
+    expect(findField('wxpay', 'publicKeyId')?.optional).toBeFalsy()
+    expect(findField('wxpay', 'certSerial')?.optional).toBeFalsy()
   })
 
   it('only keeps the simplified visible credential set in the admin form', () => {
-    expect(findField('mpAppId')).toBeUndefined()
-    expect(findField('h5AppName')).toBeUndefined()
-    expect(findField('h5AppUrl')).toBeUndefined()
+    expect(findField('wxpay', 'mpAppId')).toBeUndefined()
+    expect(findField('wxpay', 'h5AppName')).toBeUndefined()
+    expect(findField('wxpay', 'h5AppUrl')).toBeUndefined()
+  })
+})
+
+describe('PROVIDER_CONFIG_FIELDS.airwallex', () => {
+  it('adds currency config with CNY as the default', () => {
+    const currency = findField('airwallex', 'currency')
+
+    expect(currency?.defaultValue).toBe('CNY')
+    expect(currency?.hintKey).toBe('admin.settings.payment.field_paymentCurrencyHint')
+    expect(currency?.options).toBe(PAYMENT_CURRENCY_OPTIONS)
+  })
+
+  it('marks accountId as optional and explains when it can be left blank', () => {
+    const accountId = findField('airwallex', 'accountId')
+
+    expect(accountId?.optional).toBe(true)
+    expect(accountId?.clearable).toBe(true)
+    expect(accountId?.hintKey).toBe('admin.settings.payment.field_accountIdHint')
+  })
+
+  it('explains that apiBase must match the Airwallex key environment', () => {
+    expect(findField('airwallex', 'apiBase')?.hintKey).toBe('admin.settings.payment.field_airwallexApiBaseHint')
+  })
+})
+
+describe('PROVIDER_CONFIG_FIELDS.stripe', () => {
+  it('adds currency config with CNY as the default', () => {
+    const currency = findField('stripe', 'currency')
+
+    expect(currency?.defaultValue).toBe('CNY')
+    expect(currency?.hintKey).toBe('admin.settings.payment.field_paymentCurrencyHint')
+    expect(currency?.options).toBe(PAYMENT_CURRENCY_OPTIONS)
   })
 })