@owlmeans/server-payment 0.1.18-rc.12 → 0.1.18-rc.13

package/src/plugins/stripe.ts

@@ -6,9 +6,10 @@ import {
 import type { PricingPolicy } from '@owlmeans/payment'
 import type { Context as ApiContext } from '@owlmeans/server-api'
 import { STRIPE_PAYGATE_ALIAS, STRIPE_SIGNATURE } from '../consts.js'
-import { paygateCustomers, payment } from '../utils.js'
+import { paygateCustomers, payment, stripePricingConfig } from '../utils.js'
 import { isSoldThrough, planLookupKey } from '../sync.js'
 import { createEventHandler } from './events.js'
+import { settlementAmount } from './fx.js'
 import { stripeWebhookSecrets } from './webhook-manager.js'
 import type { CreateLinkParams, PaymentPlan, PaymentProduct } from '../types.js'
 
@@ -136,17 +137,27 @@ export const createCheckoutLink = async (ctx: ApiContext, stripe: Stripe, params
 
     if (plan.pricingMode === CheckoutPricingMode.Amount) {
       if (params.amountMinor == null) throw new ProductError('amount')
-      const { lineItem, chargeMinor, currency } = amountCheckoutLineItem(
+      const { chargeMinor: sourceChargeMinor, currency: amountCurrency } = amountCheckoutLineItem(
         product, plan, params.amountMinor, pricing.tax.behavior,
       )
+      const settled = await settlementAmount(ctx, stripe, sourceChargeMinor, amountCurrency)
+      const lineItem: Stripe.Checkout.SessionCreateParams.LineItem = {
+        price_data: {
+          product: product.sku, currency: settled.currency, unit_amount: settled.amountMinor,
+          tax_behavior: pricing.tax.behavior,
+        },
+        quantity: 1,
+      }
       const session = await stripe.checkout.sessions.create({
         mode: 'payment', line_items: [lineItem], invoice_creation: { enabled: true },
         ...checkoutOptions(pricing, false),
         ...sharedSession(customer, params, product, plan, {
           pricingMode: CheckoutPricingMode.Amount,
-          currency,
+          currency: settled.currency,
+          amountCurrency,
           amountMinor: String(params.amountMinor),
-          chargeAmountMinor: String(chargeMinor),
+          sourceChargeAmountMinor: String(sourceChargeMinor),
+          chargeAmountMinor: String(settled.amountMinor),
         }),
       })
       if (session.url == null) throw new PaygateError('session')
@@ -174,8 +185,12 @@ export const createCheckoutLink = async (ctx: ApiContext, stripe: Stripe, params
     ?? plans.find(item => item.recurring != null) ?? plans[0]
   if (plan == null) throw new ProductError('plan')
   const price = await findPrice(stripe, product.sku, planLookupKey(product, plan))
+  const subscriptionPaymentMethodTypes = (
+    await stripePricingConfig(ctx)
+  )?.subscriptionPaymentMethodTypes as Stripe.Checkout.SessionCreateParams.PaymentMethodType[] | undefined
   const session = await stripe.checkout.sessions.create({
     mode: 'subscription', line_items: [{ price: price.id, quantity: 1 }],
+    ...(subscriptionPaymentMethodTypes != null ? { payment_method_types: subscriptionPaymentMethodTypes } : {}),
     subscription_data: {
       metadata: {
         pricingMode: CheckoutPricingMode.Quantity, entityId: params.entityId,

package/src/sync.ts

@@ -5,6 +5,16 @@ import type { Context as ApiContext } from '@owlmeans/server-api'
 import { STRIPE_PAYGATE_ALIAS } from './consts.js'
 import { fingerprints, payment, stripeClient, stripePricingConfig } from './utils.js'
 import type { PaymentPlan, PaymentProduct } from './types.js'
+import { settlementAmount } from './plugins/fx.js'
+import type { StripeFxRateCache } from './plugins/fx.js'
+
+interface ResolvedPlan {
+  plan: PaymentPlan
+  unitAmount: number
+  currency: string
+  sourceUnitAmount: number
+  sourceCurrency: string
+}
 
 export const planLookupKey = (product: PaymentProduct, plan: PaymentPlan): string =>
   product.type === ProductType.Consumable ? `${product.sku}-consumable` : plan.sku
@@ -37,16 +47,16 @@ export const stripePlansOf = async (ctx: ApiContext): Promise<Array<{ product: P
  * edit.
  */
 const fingerprintOf = (
-  product: PaymentProduct, plans: PaymentPlan[], behavior: TaxBehavior | null,
+  product: PaymentProduct, plans: ResolvedPlan[], behavior: TaxBehavior | null,
 ): string => createHash('sha256')
   .update(JSON.stringify({
     sku: product.sku, type: product.type, name: product.title,
     description: product.description ?? null, taxCode: product.taxCode ?? null,
     unitLabel: product.unitLabel ?? null, services: [...(product.services ?? [])].sort(),
     behavior,
-    plans: plans.map(plan => ({
-      sku: plan.sku, price: plan.price, currency: plan.currency ?? 'usd', duration: plan.duration,
-      recurring: plan.recurring ?? null, pricingMode: plan.pricingMode ?? null,
+    plans: plans.map(({ plan, unitAmount, currency, sourceUnitAmount, sourceCurrency }) => ({
+      sku: plan.sku, price: plan.price, currency, unitAmount, sourceUnitAmount, sourceCurrency,
+      duration: plan.duration, recurring: plan.recurring ?? null, pricingMode: plan.pricingMode ?? null,
       amountPolicy: plan.amountPolicy ?? null, quantityPolicy: plan.quantityPolicy ?? null,
       lookup: planLookupKey(product, plan),
     })).sort((a, b) => a.sku.localeCompare(b.sku)),
@@ -121,16 +131,15 @@ const applyUnspecifiedBehavior = async (
 }
 
 const ensureStripePrice = async (
-  stripe: Stripe, product: PaymentProduct, plan: PaymentPlan,
+  stripe: Stripe, product: PaymentProduct, resolved: ResolvedPlan,
   behavior: TaxBehavior | null, migrateUnspecifiedPrices: boolean,
 ): Promise<void> => {
+  const { plan, unitAmount, currency } = resolved
   if (plan.pricingMode === CheckoutPricingMode.Amount) {
     await deactivateAmountPrice(stripe, product, plan)
     return
   }
   const lookupKey = planLookupKey(product, plan)
-  const unitAmount = Math.round(plan.price * 100)
-  const currency = plan.currency ?? 'usd'
   const recurring = plan.recurring != null
     ? { interval: plan.recurring.interval } as Stripe.PriceCreateParams.Recurring : undefined
   const existing = await activePrices(stripe, product)
@@ -169,12 +178,24 @@ export const syncStripeProducts = async (ctx: ApiContext, stripe: Stripe): Promi
   const fpRes = fingerprints(ctx)
   const behavior = (await payment(ctx).pricingPolicy()).tax.behavior ?? null
   const migrateUnspecifiedPrices = (await stripePricingConfig(ctx))?.migrateUnspecifiedPrices ?? false
+  const fxRates: StripeFxRateCache = new Map()
   for (const { product, plans } of await stripePlansOf(ctx)) {
-    const hash = fingerprintOf(product, plans, behavior)
+    const resolvedPlans: ResolvedPlan[] = []
+    for (const plan of plans) {
+      const sourceUnitAmount = Math.round(plan.price * 100)
+      const sourceCurrency = (plan.currency ?? 'usd').toLowerCase()
+      const settled = plan.pricingMode === CheckoutPricingMode.Amount
+        ? { amountMinor: sourceUnitAmount, currency: sourceCurrency }
+        : await settlementAmount(ctx, stripe, sourceUnitAmount, sourceCurrency, fxRates)
+      resolvedPlans.push({ plan, unitAmount: settled.amountMinor, currency: settled.currency, sourceUnitAmount, sourceCurrency })
+    }
+    const hash = fingerprintOf(product, resolvedPlans, behavior)
     const stored = await fpRes.bySku(product.sku)
     if (stored != null && stored.hash === hash) continue
     const stripeProduct = await ensureStripeProduct(stripe, product)
-    for (const plan of plans) await ensureStripePrice(stripe, product, plan, behavior, migrateUnspecifiedPrices)
+    for (const resolved of resolvedPlans) {
+      await ensureStripePrice(stripe, product, resolved, behavior, migrateUnspecifiedPrices)
+    }
     if (stored != null) {
       await fpRes.update({ ...stored, hash, productId: stripeProduct.id, updatedAt: new Date() })
     } else {

package/src/types.ts

@@ -80,6 +80,13 @@ export interface StripePluginConfig extends PluginConfig { api: string; webhook?
 export interface StripePricingDef {
   /** Overrides `STRIPE_FX_QUOTES_API_VERSION`, when Stripe moves or renames the preview. */
   fxApiVersion?: string
+  /**
+   * Stripe settlement currency used when a catalogue price is declared in another currency.
+   * Recurring prices are converted during product sync; amount checkout is converted per session.
+   */
+  settlementCurrency?: string
+  /** Explicit Stripe payment methods for subscription Checkout; absent keeps Stripe's dynamic selection. */
+  subscriptionPaymentMethodTypes?: string[]
   /**
    * Let a matching `unspecified` price take the declared `tax.behavior` even when the Stripe
    * account's own tax-settings default resolves to the opposite one — which changes what an
@@ -198,8 +205,15 @@ export interface QuantityTopUpCompletion extends TopUpBase {
 }
 export interface AmountTopUpCompletion extends TopUpBase {
   mode: 'amount'
+  /** Net value in the amount policy's catalogue currency. */
   amountMinor: number
+  /** Grossed-up value in the amount policy's catalogue currency, before settlement conversion. */
+  sourceChargeAmountMinor: number
+  /** The amount policy's catalogue currency. */
+  amountCurrency: string
+  /** Pre-tax subtotal actually charged by Stripe, in `currency`. */
   chargeAmountMinor: number
+  /** Stripe integration/settlement currency. */
   currency: string
 }
 export type TopUpCompletion = QuantityTopUpCompletion | AmountTopUpCompletion
@@ -400,6 +414,8 @@ export interface PaymentFulfillmentRecord extends ResourceRecord {
   mode: CheckoutPricingMode
   units?: number
   amountMinor?: number
+  sourceChargeAmountMinor?: number
+  amountCurrency?: string
   chargeAmountMinor?: number
   currency?: string
   createdAt: Date

package/tests/checkout.spec.ts

@@ -115,6 +115,20 @@ describe('Stripe checkout — pricing policy', () => {
     expect(fake.state.checkoutSessions[0].adaptive_pricing).toEqual({ enabled: true })
   })
 
+  test('subscription checkout can explicitly offer recurring-capable payment methods', async () => {
+    const fake = await makeFakeContext({
+      pricing: {
+        tax: { automatic: true, collectTaxId: true, estimate: false }, currency: { estimate: false },
+        stripe: { subscriptionPaymentMethodTypes: ['CARD', 'link', 'klarna'] },
+      },
+      stripe: { prices: [proPrice] },
+    })
+    await createCheckoutLink(fake.ctx, fake.stripe, {
+      productSku: PLANS_PRODUCT, planSku: PRO, entityId: 'entity-1', service: 'app', successUrl,
+    })
+    expect(fake.state.checkoutSessions[0].payment_method_types).toEqual(['card', 'link', 'klarna'])
+  })
+
   test('a declared behavior is set on the inline amount line item', async () => {
     const fake = await makeFakeContext({
       pricing: { tax: { automatic: true, collectTaxId: true, estimate: false, behavior: TaxBehavior.Inclusive }, currency: { estimate: false } },
@@ -124,6 +138,28 @@ describe('Stripe checkout — pricing policy', () => {
     })
     expect(fake.state.checkoutSessions[0].line_items[0].price_data.tax_behavior).toBe('inclusive')
   })
+
+  test('an amount checkout converts the USD catalogue charge to the settlement currency', async () => {
+    const fake = await makeFakeContext({
+      pricing: {
+        tax: { automatic: true, collectTaxId: true, estimate: false },
+        currency: { adaptive: true, estimate: false }, stripe: { settlementCurrency: 'EUR' },
+      },
+      stripe: { fxRates: { usd: { exchangeRate: 0.853568, referenceRate: 0.8726 } } },
+    })
+    await createCheckoutLink(fake.ctx, fake.stripe, {
+      productSku: CREDITS_PRODUCT, entityId: 'entity-1', service: 'app', amountMinor: 1_000, successUrl,
+    })
+    const session = fake.state.checkoutSessions[0]
+    expect(session.line_items[0].price_data).toEqual(expect.objectContaining({ currency: 'eur', unit_amount: 891 }))
+    expect(session.metadata).toEqual(expect.objectContaining({
+      amountMinor: '1000', sourceChargeAmountMinor: '1021', amountCurrency: 'usd',
+      chargeAmountMinor: '891', currency: 'eur',
+    }))
+    expect(fake.state.rawRequests[0]).toEqual(expect.objectContaining({
+      params: { to_currency: 'eur', 'from_currencies[]': 'usd', lock_duration: 'none' },
+    }))
+  })
 })
 
 describe('Stripe checkout fulfillment', () => {
@@ -149,6 +185,23 @@ describe('Stripe checkout fulfillment', () => {
     expect(fake.stores['payment-subscription'].rows).toHaveLength(0)
   })
 
+  test('fulfills the USD credit value from an EUR settlement charge', async () => {
+    const fake = await makeFakeContext()
+    await process(fake, 'checkout.session.completed', paid({
+      currency: 'eur', amount_subtotal: 891,
+      metadata: {
+        pricingMode: 'amount', amountMinor: '1000', sourceChargeAmountMinor: '1021', amountCurrency: 'usd',
+        chargeAmountMinor: '891', currency: 'eur', entityId: 'entity-1', service: 'app',
+        productSku: CREDITS_PRODUCT, planSku: 'app-credit-unit',
+      },
+    }))
+    expect(fake.observed.topUp[0]).toEqual(expect.objectContaining({
+      amountMinor: 1_000, sourceChargeAmountMinor: 1_021, amountCurrency: 'usd',
+      chargeAmountMinor: 891, currency: 'eur',
+    }))
+    expect(fulfillment(fake)[0]).toEqual(expect.objectContaining({ amountCurrency: 'usd', currency: 'eur' }))
+  })
+
   test('grants nothing for an unpaid completion; the asynchronous success does', async () => {
     const fake = await makeFakeContext()
     await process(fake, 'checkout.session.completed', paid({ payment_status: 'unpaid' }))

package/tests/estimate.spec.ts

@@ -174,6 +174,28 @@ describe('@owlmeans/server-payment — Stripe Tax price estimate', () => {
     }))
   })
 
+  test('estimates the same USD to EUR to local chain used by settlement and Adaptive Pricing', async () => {
+    const fake = await makeFakeContext({
+      pricing: { ...estimatingPolicy, stripe: { settlementCurrency: 'eur' } },
+      stripe: {
+        taxRates: { PL: [{ type: 'vat', percentage: '23' }] },
+        fxRates: {
+          usd: { exchangeRate: 0.853568, referenceRate: 0.8726 },
+          pln: { exchangeRate: 0.22, referenceRate: 0.224, fxFeeRate: 0.02 },
+        },
+      },
+    })
+    const result = await estimateStripePrice(fake.ctx, fake.stripe, {
+      entityId: 'entity-1', productSku: PLANS_PRODUCT, planSku: PRO, country: 'PL',
+    }, makeEstimateCache())
+    expect(result.local?.currency).toBe('pln')
+    expect(result.local?.exchangeRate).toBeCloseTo(0.22 / 0.8726)
+    expect(fake.state.rawRequests.map(request => request.params)).toEqual([
+      { to_currency: 'eur', 'from_currencies[]': 'usd', lock_duration: 'none' },
+      { to_currency: 'eur', 'from_currencies[]': 'pln', lock_duration: 'none' },
+    ])
+  })
+
   test('omits `local` when the FX Quotes call fails, without failing the estimate', async () => {
     const fake = await makeFakeContext({
       pricing: estimatingPolicy, stripe: { taxRates: { PL: [{ type: 'vat', percentage: '23' }] }, fxUnavailable: true },

package/tests/fake-stripe.ts

@@ -150,8 +150,8 @@ export interface FakeStripeState {
   taxSettings: Rec
   /** Every `rawRequest` call, in order: `{ method, path, params }`. */
   rawRequests: Rec[]
-  /** FX Quotes rates by (lowercase) local currency: USD per one unit of it. */
-  fxRates: Record<string, { exchangeRate: number, fxFeeRate?: number }>
+  /** FX Quotes rates by lowercase source currency. */
+  fxRates: Record<string, { exchangeRate: number, baseRate?: number, referenceRate?: number, fxFeeRate?: number }>
   /** Every `rawRequest` to `/v1/fx_quotes` throws. */
   fxUnavailable: boolean
 }
@@ -442,7 +442,14 @@ export const makeFakeStripe = (initial: Partial<FakeStripeState> = {}): { stripe
       }
       return {
         rates: {
-          [local]: { exchange_rate: rate.exchangeRate, rate_details: { fx_fee_rate: rate.fxFeeRate ?? 0.02 } },
+          [local]: {
+            exchange_rate: rate.exchangeRate,
+            rate_details: {
+              base_rate: rate.baseRate ?? rate.exchangeRate,
+              reference_rate: rate.referenceRate ?? rate.baseRate ?? rate.exchangeRate,
+              fx_fee_rate: rate.fxFeeRate ?? 0.02,
+            },
+          },
         },
       }
     },

package/tests/sync.spec.ts

@@ -85,4 +85,30 @@ describe('@owlmeans/server-payment — price tax_behavior sync', () => {
     expect(fresh?.id).not.toBe('price_pro_existing')
     expect(fresh).toEqual(expect.objectContaining({ tax_behavior: 'exclusive', lookup_key: PRO }))
   })
+
+  test('recurring USD catalogue prices are synchronized as EUR settlement prices', async () => {
+    const fake = await withProProduct({
+      pricing: { ...exclusive, stripe: { settlementCurrency: 'eur' } },
+      stripe: { fxRates: { usd: { exchangeRate: 0.853568, referenceRate: 0.8726 } } },
+    })
+    await syncStripeProducts(fake.ctx, fake.stripe)
+    expect(proPrice(fake)).toEqual(expect.objectContaining({ currency: 'eur', unit_amount: 1_746 }))
+    expect(fake.state.rawRequests).toContainEqual(expect.objectContaining({
+      params: { to_currency: 'eur', 'from_currencies[]': 'usd', lock_duration: 'none' },
+    }))
+  })
+
+  test('a changed reference rate replaces a recurring settlement price on the next sync', async () => {
+    const fake = await withProProduct({
+      pricing: { ...exclusive, stripe: { settlementCurrency: 'eur' } },
+      stripe: { fxRates: { usd: { exchangeRate: 0.853568, referenceRate: 0.8726 } } },
+    })
+    await syncStripeProducts(fake.ctx, fake.stripe)
+    const first = proPrice(fake)
+    fake.state.fxRates.usd = { exchangeRate: 0.88, referenceRate: 0.9 }
+    await syncStripeProducts(fake.ctx, fake.stripe)
+    expect(first?.active).toBe(false)
+    expect(proPrice(fake)).toEqual(expect.objectContaining({ currency: 'eur', unit_amount: 1_800 }))
+    expect(proPrice(fake)?.id).not.toBe(first?.id)
+  })
 })