@owlmeans/server-payment 0.1.18-rc.20 → 0.1.18-rc.21

package/src/resource.ts

@@ -1,18 +1,22 @@
 import type { ResourceMaker } from '@owlmeans/resource'
 import { makeMongoResource } from '@owlmeans/mongo-resource'
 import {
-  RES_PAYGATE_CUSTOMER, RES_PAYMENT_FINGERPRINT, RES_PAYMENT_FULFILLMENT, RES_PAYMENT_SUBSCRIPTION,
+  RES_BILLING_PROFILE, RES_CONSUMER_CONSENT, RES_CONSUMER_DECLARATION, RES_CONSUMER_EVENT, RES_PAYGATE_CUSTOMER,
+  RES_PAYMENT_FINGERPRINT, RES_PAYMENT_FULFILLMENT, RES_PAYMENT_PURCHASE, RES_PAYMENT_SUBSCRIPTION,
   RES_PAYMENT_USAGE, RES_PAYMENT_USAGE_COUNTER, RES_PAYMENT_WEBHOOK,
 } from './consts.js'
 import {
-  FingerprintSchema, PaygateCustomerSchema, PaymentFulfillmentSchema, PaymentSubscriptionSchema,
-  PaymentUsageCounterSchema, PaymentUsageSchema, PaymentWebhookSchema,
+  BillingProfileSchema, ConsumerConsentSchema, ConsumerDeclarationSchema, ConsumerEventSchema, FingerprintSchema,
+  PaygateCustomerSchema, PaymentFulfillmentSchema, PaymentSubscriptionSchema, PaymentUsageCounterSchema,
+  PaymentUsageSchema, PaymentWebhookSchema, PurchaseSchema,
 } from './model.js'
 import type {
+  BillingProfileRecord, BillingProfileResource, ConsumerConsentRecord, ConsumerConsentResource,
+  ConsumerDeclarationRecord, ConsumerDeclarationResource, ConsumerEventRecord, ConsumerEventResource,
   FingerprintRecord, FingerprintResource, PaygateCustomerRecord, PaygateCustomerResource,
   PaymentFulfillmentRecord, PaymentFulfillmentResource, PaymentSubscriptionRecord,
   PaymentSubscriptionResource, PaymentUsageCounterRecord, PaymentUsageCounterResource, PaymentUsageRecord,
-  PaymentUsageResource, PaymentWebhookRecord, PaymentWebhookResource,
+  PaymentUsageResource, PaymentWebhookRecord, PaymentWebhookResource, PurchaseRecord, PurchaseResource,
 } from './types.js'
 
 export const makePaygateCustomerResource: ResourceMaker<PaygateCustomerRecord, PaygateCustomerResource> = (
@@ -111,3 +115,82 @@ export const makeFingerprintResource: ResourceMaker<FingerprintRecord, Fingerpri
   resource.index('sku', { sku: 1 }, { unique: true })
   return resource
 }
+
+export const makeBillingProfileResource: ResourceMaker<BillingProfileRecord, BillingProfileResource> = (
+  dbAlias, serviceAlias,
+) => {
+  const resource = makeMongoResource<BillingProfileRecord, BillingProfileResource>(
+    RES_BILLING_PROFILE, dbAlias, serviceAlias,
+  )
+  resource.byEntity = async entityId => await resource.load({ entityId })
+  resource.schema = BillingProfileSchema
+  // One profile per organization: the unique index is what makes the first lock the only one.
+  resource.index('entity', { entityId: 1 }, { unique: true })
+  resource.index('customer', { paygate: 1, customerId: 1 }, { sparse: true })
+  return resource
+}
+
+export const makePurchaseResource: ResourceMaker<PurchaseRecord, PurchaseResource> = (dbAlias, serviceAlias) => {
+  const resource = makeMongoResource<PurchaseRecord, PurchaseResource>(RES_PAYMENT_PURCHASE, dbAlias, serviceAlias)
+  resource.byPurchaseId = async purchaseId => await resource.load({ purchaseId })
+  resource.schema = PurchaseSchema
+  resource.index('purchase', { purchaseId: 1 }, { unique: true })
+  resource.index('contract', { contractRef: 1 }, { unique: true })
+  resource.index('entityDeadline', { entityId: 1, deadline: -1 })
+  resource.index('entityPurchased', { entityId: 1, purchasedAt: -1 })
+  // Single-field on purpose: a compound sparse index still indexes rows missing only `sessionId`
+  // (subscription purchases before their checkout is captured), and unique would collide on them.
+  resource.index('session', { sessionId: 1 }, { unique: true, sparse: true })
+  resource.index('subscription', { paygate: 1, subscriptionId: 1 }, { sparse: true })
+  resource.index('invoice', { invoiceId: 1 }, { sparse: true })
+  resource.index('invoiceNumber', { invoiceNumber: 1 }, { sparse: true })
+  resource.index('paymentIntent', { paygate: 1, paymentIntentId: 1 }, { sparse: true })
+  return resource
+}
+
+export const makeConsumerConsentResource: ResourceMaker<ConsumerConsentRecord, ConsumerConsentResource> = (
+  dbAlias, serviceAlias,
+) => {
+  const resource = makeMongoResource<ConsumerConsentRecord, ConsumerConsentResource>(
+    RES_CONSUMER_CONSENT, dbAlias, serviceAlias,
+  )
+  resource.schema = ConsumerConsentSchema
+  resource.index('entityDecided', { entityId: 1, decidedAt: -1 })
+  resource.index('kindPlan', { kind: 1, entityId: 1, planSku: 1, decidedAt: -1 })
+  return resource
+}
+
+export const makeConsumerDeclarationResource: ResourceMaker<ConsumerDeclarationRecord, ConsumerDeclarationResource> = (
+  dbAlias, serviceAlias,
+) => {
+  const resource = makeMongoResource<ConsumerDeclarationRecord, ConsumerDeclarationResource>(
+    RES_CONSUMER_DECLARATION, dbAlias, serviceAlias,
+  )
+  resource.schema = ConsumerDeclarationSchema
+  resource.index('kindReceived', { kind: 1, receivedAt: -1 })
+  resource.index('entityReceived', { entityId: 1, receivedAt: -1 }, { sparse: true })
+  resource.index('purchase', { purchaseId: 1 }, { sparse: true })
+  return resource
+}
+
+export const makeConsumerEventResource: ResourceMaker<ConsumerEventRecord, ConsumerEventResource> = (
+  dbAlias, serviceAlias,
+) => {
+  const resource = makeMongoResource<ConsumerEventRecord, ConsumerEventResource>(
+    RES_CONSUMER_EVENT, dbAlias, serviceAlias,
+  )
+  resource.schema = ConsumerEventSchema
+  resource.index('record', { recordId: 1, at: 1 })
+  resource.index('entityAt', { entityId: 1, at: -1 }, { sparse: true })
+  resource.index('actionOk', { action: 1, ok: 1, at: 1 })
+  return resource
+}
+
+/** The consumer-rights resources, alias → maker — registered by the gateway, each only when absent. */
+export const CONSUMER_RIGHTS_RESOURCE_MAKERS = [
+  [RES_BILLING_PROFILE, makeBillingProfileResource],
+  [RES_PAYMENT_PURCHASE, makePurchaseResource],
+  [RES_CONSUMER_CONSENT, makeConsumerConsentResource],
+  [RES_CONSUMER_DECLARATION, makeConsumerDeclarationResource],
+  [RES_CONSUMER_EVENT, makeConsumerEventResource],
+] as const

package/src/service.ts

@@ -10,6 +10,7 @@ import {
   ENTITLEMENT_SERVICE, GATEWAY_SERVICE, RES_PAYGATE_CUSTOMER, RES_PAYMENT_FINGERPRINT, RES_PAYMENT_FULFILLMENT,
   RES_PAYMENT_SUBSCRIPTION, RES_PAYMENT_USAGE, RES_PAYMENT_USAGE_COUNTER, RES_PAYMENT_WEBHOOK,
 } from './consts.js'
+import { registerConsumerRights } from './consumer/service.js'
 import { makeEntitlementService } from './entitlement.js'
 import { makeCapabilityGate } from './gate.js'
 import { makeLimitGate } from './limit.js'
@@ -18,17 +19,18 @@ import { findPlan, findProduct, planRank } from './plan.js'
 import { resyncStripeSubscription, resyncStripeSubscriptions } from './plugins/events.js'
 import { makeEstimateCache, estimateStripePrice } from './plugins/estimate.js'
 import { createPortalLink, ensurePortalConfiguration } from './plugins/portal.js'
-import { createCheckoutLink } from './plugins/stripe.js'
+import { makeCheckoutPluginRegistry, narrowAmountFor } from './plugins/checkout-plugins.js'
+import { consumablePlanOf, createCheckoutLink } from './plugins/stripe.js'
 import { ensureWebhookEndpoint } from './plugins/webhook-manager.js'
 import {
   makeFingerprintResource, makeFulfillmentResource, makePaygateCustomerResource, makeSubscriptionResource,
   makeUsageCounterResource, makeUsageResource, makeWebhookResource,
 } from './resource.js'
 import { commitSubscription } from './subscription.js'
-import { syncStripeProducts } from './sync.js'
-import { stripeClient, subscriptions } from './utils.js'
+import { syncedPlanPrices, syncStripeProducts } from './sync.js'
+import { consumerRightsOf, stripeClient, subscriptions } from './utils.js'
 import type {
-  Config, Context, GatewayService, GrantInternalPlanOptions, PaymentGatewayOptions,
+  Config, Context, GatewayService, GrantInternalPlanOptions, PaymentGatewayOptions, PaymentPlan,
   PaymentSubscriptionRecord,
 } from './types.js'
 
@@ -107,10 +109,22 @@ export const makeGatewayService = (
   // One estimate cache per gateway SERVICE instance, never module-level: several service
   // instances (several tests, several deployments in one process) must never share hits.
   const estimateCache = makeEstimateCache()
+  // Checkout plugins are seated per gateway instance, like the estimate cache.
+  const plugins = makeCheckoutPluginRegistry()
   const service = createService<GatewayService>(alias, {
     managed,
     createLink: async (ctx, params) => managed
-      ? await createCheckoutLink(ctx, await stripeClient(ctx), params) : unmanaged(),
+      ? await createCheckoutLink(ctx, await stripeClient(ctx), params, plugins.list()) : unmanaged(),
+    use: plugin => { plugins.use(plugin) },
+    checkoutPlugins: () => plugins.list(),
+    amountPolicy: async (ctx, entityId, productSku, planSku) => {
+      const { plan } = await consumablePlanOf(ctx, productSku, planSku)
+      if (plan.amountPolicy == null) throw new ProductError(`amount-policy:${plan.sku}`)
+      return await narrowAmountFor(ctx, plugins.list(), {
+        entityId, productSku, planSku: (plan as PaymentPlan).sku, base: plan.amountPolicy, at: new Date(),
+      })
+    },
+    planPrices: async (ctx, productSku) => await syncedPlanPrices(ctx, productSku),
     portalLink: async (ctx, entityId, link) => managed
       ? await createPortalLink(ctx, await stripeClient(ctx), entityId, link) : unmanaged(),
     grantInternalPlan: async (ctx, entityId, planSku, grant) => await grantInternalPlan(ctx, entityId, planSku, grant),
@@ -124,6 +138,9 @@ export const makeGatewayService = (
     const ctx = service.assertCtx() as unknown as ApiContext
     assertPlanDeclarations(ctx.cfg)
     service.initialized = true
+    // The consumer-rights service is lazy (reachable while the application is wired): initialize it
+    // with the gateway, so its boot checks run at boot.
+    consumerRightsOf(ctx)
     if (managed) {
       void ctx.waitForInitialized().then(async () => {
         await bootstrapStripe(ctx, await stripeClient(ctx))
@@ -136,7 +153,8 @@ export const makeGatewayService = (
 
 /**
  * Register the payment resources, the catalogue service, the completion observer, the gateway, both
- * gate services and the entitlement service — each only when not registered yet.
+ * gate services, the entitlement service and the consumer-rights records and service — each only
+ * when not registered yet.
  *
  * `manage: false` registers the same surface for a process that reads entitlements but never talks
  * to Stripe.
@@ -164,6 +182,10 @@ export const appendPaymentGatewayService = <C extends Config, T extends Context<
   if (!ctx.hasService(ENTITLEMENT_GATE)) ctx.registerService(makeCapabilityGate())
   if (!ctx.hasService(LIMIT_GATE)) ctx.registerService(makeLimitGate())
   if (!ctx.hasService(ENTITLEMENT_SERVICE)) ctx.registerService(makeEntitlementService())
+  // The consumer-rights records and service, with this gateway's `manage` unless the application
+  // gave its own (before or after this call): the webhook writes purchases and locks, and an
+  // unmanaged process still reads and asserts consent.
+  registerConsumerRights(ctx, { manage: opts?.manage, dbAlias: opts?.dbAlias, serviceAlias: opts?.serviceAlias }, 'gateway')
 
   return ctx
 }

package/src/subscription.ts

@@ -14,6 +14,12 @@ export interface CommitOptions {
   invoiceId?: string
   /** The paygate announced the trial ends soon. */
   trialEnding?: boolean
+  /**
+   * Runs after the new state is written and BEFORE observers hear the change — what must exist
+   * before an observer grants anything (a subscription's purchase row). A throw propagates: the
+   * observers are not told and the paygate retries.
+   */
+  beforePropagate?: (record: PaymentSubscriptionRecord, change: SubscriptionChange) => Promise<void>
 }
 
 export interface CommitResult {
@@ -205,6 +211,7 @@ export const commitSubscription = async (
   }
 
   const stored = await write(next)
+  await opts.beforePropagate?.(stored, change)
   await observer(ctx).propagateSubscription({
     change,
     previous: prior != null && previous != null ? await snapshotOf(ctx, previous, prior) : null,

package/src/sync.ts

@@ -1,10 +1,11 @@
 import { createHash } from 'node:crypto'
 import type Stripe from 'stripe'
 import { CheckoutPricingMode, ProductType, TaxBehavior } from '@owlmeans/payment'
+import type { PlanPriceView } from '@owlmeans/payment'
 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 type { PaymentPlan, PaymentProduct, SyncedPrice, SyncedPriceOption } from './types.js'
 import { settlementAmount } from './plugins/fx.js'
 import type { StripeFxRateCache } from './plugins/fx.js'
 
@@ -14,6 +15,39 @@ interface ResolvedPlan {
   currency: string
   sourceUnitAmount: number
   sourceCurrency: string
+  /** `currency_options` besides `currency`, sorted by currency. */
+  options: SyncedPriceOption[]
+}
+
+/**
+ * The exact prices a plan is also charged in: its declared `currencyPrices`, and its catalogue
+ * currency when that is one of the consumer-rights region currencies but not the Price's default
+ * (a USD catalogue price synced as EUR keeps an exact USD option). A declared price in the default
+ * currency replaces the converted default amount instead.
+ */
+const optionsOf = (
+  plan: PaymentPlan, currency: string, sourceUnitAmount: number, sourceCurrency: string, regionCurrencies: Set<string>,
+): { unitAmount?: number, options: SyncedPriceOption[] } => {
+  const options = new Map<string, number>()
+  if (sourceCurrency !== currency && regionCurrencies.has(sourceCurrency)) {
+    options.set(sourceCurrency, sourceUnitAmount)
+  }
+  let unitAmount: number | undefined
+  for (const [raw, amount] of Object.entries(plan.currencyPrices ?? {})) {
+    const code = raw.toLowerCase()
+    const minor = Math.round(amount * 100)
+    if (code === currency) {
+      unitAmount = minor
+    } else {
+      options.set(code, minor)
+    }
+  }
+
+  return {
+    ...(unitAmount != null ? { unitAmount } : {}),
+    options: [...options.entries()].map(([code, amount]) => ({ currency: code, unitAmount: amount }))
+      .sort((a, b) => a.currency.localeCompare(b.currency)),
+  }
 }
 
 export const planLookupKey = (product: PaymentProduct, plan: PaymentPlan): string =>
@@ -54,11 +88,13 @@ const fingerprintOf = (
     description: product.description ?? null, taxCode: product.taxCode ?? null,
     unitLabel: product.unitLabel ?? null, services: [...(product.services ?? [])].sort(),
     behavior,
-    plans: plans.map(({ plan, unitAmount, currency, sourceUnitAmount, sourceCurrency }) => ({
+    plans: plans.map(({ plan, unitAmount, currency, sourceUnitAmount, sourceCurrency, options }) => ({
       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),
+      // Only when present, so a catalogue without options keeps the fingerprint it always had.
+      ...(options.length > 0 ? { options } : {}),
     })).sort((a, b) => a.sku.localeCompare(b.sku)),
   })).digest('hex')
 
@@ -78,7 +114,23 @@ const ensureStripeProduct = async (stripe: Stripe, product: PaymentProduct): Pro
 }
 
 const activePrices = async (stripe: Stripe, product: PaymentProduct): Promise<Stripe.Price[]> =>
-  (await stripe.prices.list({ product: product.sku, active: true, limit: 100 })).data
+  (await stripe.prices.list({ product: product.sku, active: true, limit: 100, expand: ['data.currency_options'] })).data
+
+/** A price's `currency_options` besides its default currency (read only once expanded). */
+const priceOptionsOf = (price: Stripe.Price): Record<string, { unit_amount?: number | null, tax_behavior?: string | null }> =>
+  Object.fromEntries(Object.entries(price.currency_options ?? {}).filter(([code]) => code !== price.currency))
+
+/** Whether a price carries exactly these options (and, with a declared behavior, with that behavior). */
+const optionsMatch = (price: Stripe.Price, options: SyncedPriceOption[], behavior: TaxBehavior | null): boolean => {
+  const current = priceOptionsOf(price)
+  if (Object.keys(current).length !== options.length) {
+    return false
+  }
+
+  return options.every(option => current[option.currency]?.unit_amount === option.unitAmount
+    && (behavior == null || current[option.currency]?.tax_behavior == null
+      || current[option.currency]?.tax_behavior === 'unspecified' || current[option.currency]?.tax_behavior === behavior))
+}
 
 const deactivateAmountPrice = async (stripe: Stripe, product: PaymentProduct, plan: PaymentPlan): Promise<void> => {
   const lookup = planLookupKey(product, plan)
@@ -133,11 +185,11 @@ const applyUnspecifiedBehavior = async (
 const ensureStripePrice = async (
   stripe: Stripe, product: PaymentProduct, resolved: ResolvedPlan,
   behavior: TaxBehavior | null, migrateUnspecifiedPrices: boolean,
-): Promise<void> => {
-  const { plan, unitAmount, currency } = resolved
+): Promise<Stripe.Price | null> => {
+  const { plan, unitAmount, currency, options } = resolved
   if (plan.pricingMode === CheckoutPricingMode.Amount) {
     await deactivateAmountPrice(stripe, product, plan)
-    return
+    return null
   }
   const lookupKey = planLookupKey(product, plan)
   const recurring = plan.recurring != null
@@ -145,21 +197,30 @@ const ensureStripePrice = async (
   const existing = await activePrices(stripe, product)
   const candidate = existing.find(price => price.lookup_key === lookupKey && price.unit_amount === unitAmount
     && price.currency === currency
-    && ((price.recurring?.interval ?? null) === (recurring?.interval ?? null)))
+    && ((price.recurring?.interval ?? null) === (recurring?.interval ?? null))
+    && optionsMatch(price, options, behavior))
   if (candidate != null && !opposesBehavior(candidate, behavior)) {
     if (behavior != null && candidate.tax_behavior === 'unspecified') {
       await applyUnspecifiedBehavior(stripe, candidate, lookupKey, behavior, migrateUnspecifiedPrices)
     }
-    return
+    return candidate
   }
+  // A changed option replaces the Price like any other change — options are never edited in place,
+  // so a subscriber keeps exactly the Price (and currency amounts) they accepted.
   for (const price of existing.filter(item => item.lookup_key === lookupKey)) {
     await stripe.prices.update(price.id, { active: false })
   }
-  await stripe.prices.create({
+
+  return await stripe.prices.create({
     product: product.sku, currency, unit_amount: unitAmount, lookup_key: lookupKey,
     transfer_lookup_key: true, nickname: plan.sku,
     ...(recurring != null ? { recurring } : { billing_scheme: 'per_unit' }),
     ...(behavior != null ? { tax_behavior: behavior } : {}),
+    ...(options.length > 0 ? {
+      currency_options: Object.fromEntries(options.map(option => [option.currency, {
+        unit_amount: option.unitAmount, ...(behavior != null ? { tax_behavior: behavior } : {}),
+      }])),
+    } : {}),
     metadata: { sku: plan.sku, ...(product.services && { services: product.services.join(',') }) },
   })
 }
@@ -179,32 +240,78 @@ export const syncStripeProducts = async (ctx: ApiContext, stripe: Stripe): Promi
   const behavior = (await payment(ctx).pricingPolicy()).tax.behavior ?? null
   const migrateUnspecifiedPrices = (await stripePricingConfig(ctx))?.migrateUnspecifiedPrices ?? false
   const fxRates: StripeFxRateCache = new Map()
+  const rights = await payment(ctx).consumerRightsPolicy()
+  const regionCurrencies = new Set(Object.values(rights?.currencies ?? {})
+    .filter((code): code is string => typeof code === 'string').map(code => code.toLowerCase()))
   for (const { product, plans } of await stripePlansOf(ctx)) {
     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 })
+      if (plan.pricingMode === CheckoutPricingMode.Amount) {
+        resolvedPlans.push({ plan, unitAmount: sourceUnitAmount, currency: sourceCurrency, sourceUnitAmount, sourceCurrency, options: [] })
+        continue
+      }
+      const settled = await settlementAmount(ctx, stripe, sourceUnitAmount, sourceCurrency, fxRates)
+      const { unitAmount, options } = optionsOf(plan, settled.currency, sourceUnitAmount, sourceCurrency, regionCurrencies)
+      resolvedPlans.push({
+        plan, unitAmount: unitAmount ?? settled.amountMinor, currency: settled.currency, sourceUnitAmount, sourceCurrency,
+        options,
+      })
     }
     const hash = fingerprintOf(product, resolvedPlans, behavior)
     const stored = await fpRes.bySku(product.sku)
-    if (stored != null && stored.hash === hash) continue
+    // A row from before prices were persisted syncs once more, so `planPrices` can read it.
+    if (stored != null && stored.hash === hash && stored.prices != null) continue
     const stripeProduct = await ensureStripeProduct(stripe, product)
+    const prices: SyncedPrice[] = []
+    const syncedAt = new Date()
     for (const resolved of resolvedPlans) {
-      await ensureStripePrice(stripe, product, resolved, behavior, migrateUnspecifiedPrices)
+      const price = await ensureStripePrice(stripe, product, resolved, behavior, migrateUnspecifiedPrices)
+      if (price != null) {
+        prices.push({
+          planSku: resolved.plan.sku, priceId: price.id, lookupKey: planLookupKey(product, resolved.plan),
+          currency: resolved.currency, unitAmount: resolved.unitAmount, options: resolved.options,
+          ...(behavior != null ? { taxBehavior: behavior } : price.tax_behavior != null ? { taxBehavior: price.tax_behavior } : {}),
+          ...(resolved.plan.recurring != null ? { interval: resolved.plan.recurring.interval } : {}),
+          sourceUnitAmount: resolved.sourceUnitAmount, sourceCurrency: resolved.sourceCurrency, syncedAt,
+        })
+      }
     }
     if (stored != null) {
-      await fpRes.update({ ...stored, hash, productId: stripeProduct.id, updatedAt: new Date() })
+      await fpRes.update({ ...stored, hash, productId: stripeProduct.id, prices, updatedAt: new Date() })
     } else {
-      await fpRes.create({ sku: product.sku, hash, productId: stripeProduct.id, updatedAt: new Date() })
+      await fpRes.create({ sku: product.sku, hash, productId: stripeProduct.id, prices, updatedAt: new Date() })
     }
     console.info(`[payment] synced product '${product.sku}' to Stripe (${plans.length} plan(s))`)
   }
 }
 
+/**
+ * The prices a product's plans are charged at, per currency, as the last sync stored them — no
+ * paygate call, so it works in an unmanaged process. One entry for each Price's default currency
+ * (`default: true`) and one per currency option.
+ */
+export const syncedPlanPrices = async (ctx: ApiContext, productSku: string): Promise<PlanPriceView[]> => {
+  const row = await fingerprints(ctx).bySku(productSku)
+  const behaviorOf = (value: string | undefined): TaxBehavior | undefined =>
+    value === TaxBehavior.Exclusive || value === TaxBehavior.Inclusive ? value : undefined
+  const views: PlanPriceView[] = []
+  for (const price of row?.prices ?? []) {
+    const taxBehavior = behaviorOf(price.taxBehavior ?? undefined)
+    const shared = {
+      planSku: price.planSku, ...(taxBehavior != null ? { taxBehavior } : {}),
+      ...(price.interval != null ? { interval: price.interval } : {}),
+    }
+    views.push({ ...shared, currency: price.currency, unitAmountMinor: price.unitAmount, default: true })
+    for (const option of price.options ?? []) {
+      views.push({ ...shared, currency: option.currency, unitAmountMinor: option.unitAmount, default: false })
+    }
+  }
+
+  return views
+}
+
 /** `syncStripeProducts` with this context's own Stripe client. */
 export const syncPaymentProducts = async (ctx: ApiContext): Promise<void> =>
   await syncStripeProducts(ctx, await stripeClient(ctx))