Skip to content

Self-hosted personal gallery application with online photo management and albums, supporting Live/Motion Photos, EXIF parsing, geolocation recognition, and an explore map.

feat(payments): integrate Dodo SDK with isolated profiles and plan discounts

Timothy Yinc733f9dffddb
diff --git a/apps/cloud/app/components/CloudPricing.vue b/apps/cloud/app/components/CloudPricing.vue
index 5802b490..8616c6f8 100644
--- a/apps/cloud/app/components/CloudPricing.vue
+++ b/apps/cloud/app/components/CloudPricing.vue
@@ -64,8 +64,16 @@ const comparisonRows = computed(() =>
)
if (billing) await billing.ready
const currentPlan = computed(() => billing?.data.value?.plan.id)
-const amount = (plan: any) =>
+const originalAmount = (plan: any) =>
interval.value === 1 ? plan.monthlyPrice : plan.quarterlyPrice
+const amount = (plan: any) =>
+ interval.value === 1
+ ? (plan.monthlyEffectivePrice ?? plan.monthlyPrice)
+ : (plan.quarterlyEffectivePrice ?? plan.quarterlyPrice)
+const discountBps = (plan: any) =>
+ interval.value === 1
+ ? (plan.monthlyDiscountBps ?? 0)
+ : (plan.quarterlyDiscountBps ?? 0)
const action = (plan: any) =>
amount(plan) === 0 ? links.signup : links.purchase(plan.id, interval.value)
const payment = computed(() => payments?.data.value),
@@ -229,6 +237,19 @@ async function checkout(plan: any) {
<p class="cf-plan-description">
{{ plan.description || $t('cloud.billing.simplePlan') }}
</p>
+ <p
+ v-if="discountBps(plan) > 0 && originalAmount(plan) > 0"
+ class="cf-price-caption cf-plan-discount"
+ >
+ <del>{{ price(originalAmount(plan), plan.currency, locale) }}</del>
+ <CfBadge
+ >−{{
+ new Intl.NumberFormat(locale, {
+ maximumFractionDigits: 2,
+ }).format(discountBps(plan) / 100)
+ }}%</CfBadge
+ >
+ </p>
<div class="cf-plan-price">
<strong>{{
amount(plan) === 0
diff --git a/apps/cloud/app/composables/useDodoCheckoutReturn.ts b/apps/cloud/app/composables/useDodoCheckoutReturn.ts
new file mode 100644
index 00000000..050ffe71
--- /dev/null
+++ b/apps/cloud/app/composables/useDodoCheckoutReturn.ts
@@ -0,0 +1,72 @@
+import type { MaybeRefOrGetter } from 'vue'
+/** A return triggers an authenticated provider check; URL payment/subscription IDs are ignored. */
+export function useDodoCheckoutReturn(
+ workspaceId: MaybeRefOrGetter<number>,
+ enabled: MaybeRefOrGetter<boolean>,
+ refresh: () => Promise<void>,
+) {
+ const route = useRoute(),
+ state = ref('idle')
+ let generation = 0,
+ alive = true,
+ timer: ReturnType<typeof setTimeout> | undefined
+ async function check() {
+ const current = ++generation
+ if (timer) clearTimeout(timer)
+ const id = toValue(workspaceId),
+ checkout = route.query.checkout
+ if (!toValue(enabled) || !id || typeof checkout !== 'string') {
+ state.value = 'idle'
+ return
+ }
+ state.value = 'checking'
+ async function poll(attempt: number): Promise<void> {
+ if (!alive || current !== generation) return
+ try {
+ const result = await $fetch<{ state: string }>(
+ '/api/billing/payments',
+ {
+ method: 'POST',
+ body: { action: 'refresh', workspaceId: id, checkoutId: checkout },
+ },
+ )
+ if (!alive || current !== generation) return
+ await refresh()
+ if (!alive || current !== generation) return
+ if (['completed', 'expired'].includes(result.state)) {
+ state.value = result.state
+ return
+ }
+ } catch (error: any) {
+ if (!alive || current !== generation) return
+ if (
+ [400, 401, 403, 404, 410, 503].includes(
+ error?.statusCode ?? error?.status,
+ )
+ ) {
+ state.value = 'failed'
+ return
+ }
+ }
+ if (attempt >= 7) {
+ state.value = 'pending'
+ return
+ }
+ timer = setTimeout(() => void poll(attempt + 1), 5000)
+ }
+ await poll(0)
+ }
+ onMounted(() =>
+ watch(
+ () => [toValue(workspaceId), toValue(enabled), route.query.checkout],
+ () => void check(),
+ { immediate: true },
+ ),
+ )
+ onBeforeUnmount(() => {
+ alive = false
+ generation++
+ if (timer) clearTimeout(timer)
+ })
+ return { state, retry: check }
+}
diff --git a/apps/cloud/app/pages/account/plan.vue b/apps/cloud/app/pages/account/plan.vue
index 3621c616..d4cd22a5 100644
--- a/apps/cloud/app/pages/account/plan.vue
+++ b/apps/cloud/app/pages/account/plan.vue
@@ -7,6 +7,13 @@ const { t, locale } = useI18n(),
const { selected, data, error, listError, status, refresh, retry, ready } =
billing
const payments = useCloudPayments(() => selected.value)
+const returned = useDodoCheckoutReturn(
+ () => selected.value,
+ () => !!payments.data.value?.enabled,
+ async () => {
+ await Promise.all([refresh(), payments.refresh()])
+ },
+)
const latestSubscription = computed(() => {
const rows = payments.data.value?.subscriptions ?? []
return (
@@ -43,6 +50,19 @@ const date = (time: number) => new Date(time).toLocaleString(locale.value)
<p class="cf-page-description">{{ $t('cloud.billing.planHelp') }}</p>
</div>
</div>
+ <p
+ v-if="returned.state.value !== 'idle'"
+ class="cf-notice"
+ role="status"
+ >
+ {{ $t('cloud.payments.return_' + returned.state.value) }}
+ <CfButton
+ v-if="['pending', 'failed'].includes(returned.state.value)"
+ variant="ghost"
+ @click="returned.retry"
+ >{{ $t('cloud.payments.checkAgain') }}</CfButton
+ >
+ </p>
<CfCard
v-if="error || listError"
role="alert"
diff --git a/apps/cloud/i18n/locales/en.json b/apps/cloud/i18n/locales/en.json
index 7f2647cb..ed3fd862 100644
--- a/apps/cloud/i18n/locales/en.json
+++ b/apps/cloud/i18n/locales/en.json
@@ -698,6 +698,8 @@
"subscribe": "Subscribe in test mode",
"manageExisting": "Manage your existing subscription",
"status": {
+ "pending": "Pending",
+ "failed": "Failed",
"active": "Active",
"trialing": "Trialing",
"scheduled_cancel": "Cancels at period end",
diff --git a/apps/cloud/i18n/locales/zh-Hans.json b/apps/cloud/i18n/locales/zh-Hans.json
index c4f51cbe..62c6ee69 100644
--- a/apps/cloud/i18n/locales/zh-Hans.json
+++ b/apps/cloud/i18n/locales/zh-Hans.json
@@ -698,6 +698,8 @@
"subscribe": "测试订阅",
"manageExisting": "已有订阅,请前往账单管理",
"status": {
+ "pending": "待确认",
+ "failed": "失败",
"active": "有效",
"trialing": "试用中",
"scheduled_cancel": "周期结束后取消",
diff --git a/apps/cloud/server/api/webhooks/dodo/[profileId].post.ts b/apps/cloud/server/api/webhooks/dodo/[profileId].post.ts
new file mode 100644
index 00000000..82a81be0
--- /dev/null
+++ b/apps/cloud/server/api/webhooks/dodo/[profileId].post.ts
@@ -0,0 +1,59 @@
+import { createError, getHeader, getRequestWebStream, getRouterParam } from 'h3'
+import { receiveDodoEvent } from '../../../../../../packages/platform/src/dodo-payments'
+import {
+ definePlatformHandler,
+ platformDatabase,
+} from '../../../../../shared/platform/runtime'
+export default definePlatformHandler(async (event) => {
+ const profileId = getRouterParam(event, 'profileId')
+ if (!profileId || !/^[a-z][a-z0-9_-]{0,63}$/.test(profileId))
+ throw createError({ statusCode: 404 })
+ const db = platformDatabase(event)
+ const profile = await db
+ .prepare(
+ "SELECT environment FROM platform_payment_providers WHERE id=? AND provider='dodo'",
+ )
+ .bind(profileId)
+ .first<any>()
+ if (!profile) throw createError({ statusCode: 404 })
+ const environment = profile.environment as 'test' | 'live'
+ const stream = getRequestWebStream(event)
+ if (!stream) throw createError({ statusCode: 400 })
+ const reader = stream.getReader(),
+ chunks: Uint8Array[] = []
+ let size = 0
+ try {
+ while (true) {
+ const { done, value } = await reader.read()
+ if (done) break
+ size += value.byteLength
+ if (size > 65536) {
+ await reader.cancel()
+ throw createError({ statusCode: 413 })
+ }
+ chunks.push(value)
+ }
+ } finally {
+ reader.releaseLock()
+ }
+ const body = new Uint8Array(size)
+ let offset = 0
+ for (const chunk of chunks) {
+ body.set(chunk, offset)
+ offset += chunk.byteLength
+ }
+ return receiveDodoEvent(
+ platformDatabase(event),
+ useRuntimeConfig(event).platform.storageSecret,
+ environment,
+ body,
+ {
+ 'webhook-id': getHeader(event, 'webhook-id') ?? '',
+ 'webhook-timestamp': getHeader(event, 'webhook-timestamp') ?? '',
+ 'webhook-signature': getHeader(event, 'webhook-signature') ?? '',
+ },
+ undefined,
+ undefined,
+ profileId,
+ )
+})
diff --git a/apps/cloud/server/middleware/platform-boundary.ts b/apps/cloud/server/middleware/platform-boundary.ts
index 6b6a44be..b2a61ab8 100644
--- a/apps/cloud/server/middleware/platform-boundary.ts
+++ b/apps/cloud/server/middleware/platform-boundary.ts
@@ -28,6 +28,7 @@ export default defineEventHandler((event) => {
'/api/webhooks/creem',
'/api/workspaces/default',
].includes(path) ||
+ /^\/api\/webhooks\/dodo\/[a-z][a-z0-9_-]{0,63}$/.test(path) ||
/^\/api\/sites\/[1-9][0-9]*\/(?:context|events|settings|domains)$/.test(
path,
)
diff --git a/apps/cloud/server/plugins/payments.ts b/apps/cloud/server/plugins/payments.ts
index fec8f36e..8753fa6a 100644
--- a/apps/cloud/server/plugins/payments.ts
+++ b/apps/cloud/server/plugins/payments.ts
@@ -1,3 +1,7 @@
+import {
+ syncDodoProducts,
+ reconcileDodoPayments,
+} from '../../../../packages/platform/src/dodo-payments'
import { expirePaymentEventPayloads } from '../../../../packages/platform/src/payment-events'
import type { PlatformD1 } from '@chronoframe/platform'
@@ -5,9 +9,17 @@ export default defineNitroPlugin((app) => {
app.hooks.hook('cloudflare:scheduled', async ({ env }) => {
const db = env.DB as PlatformD1 | undefined
// Local data retention continues independently of payment availability.
- if (db)
+ if (db) {
+ const secret = String(env.NUXT_PLATFORM_STORAGE_SECRET || '')
+ await syncDodoProducts(db, secret).catch(() =>
+ console.error('dodo_product_sync_failed'),
+ )
+ await reconcileDodoPayments(db, secret).catch(() =>
+ console.error('dodo_reconciliation_failed'),
+ )
await expirePaymentEventPayloads(db).catch(() =>
console.error('payment_payload_expiry_failed'),
)
+ }
})
})
diff --git a/packages/contracts/src/pricing.ts b/packages/contracts/src/pricing.ts
new file mode 100644
index 00000000..22f0c18e
--- /dev/null
+++ b/packages/contracts/src/pricing.ts
@@ -0,0 +1,4 @@
+/** Round the discounted minor-unit amount once, using the same basis-point rate sent to the provider. */
+export function discountedPrice(amount: number | null, discountBps = 0): number | null {
+ return amount === null ? null : Math.floor((amount * (10000 - discountBps) + 5000) / 10000)
+}
diff --git a/packages/platform/migrations/0029_dodo_payments.sql b/packages/platform/migrations/0029_dodo_payments.sql
new file mode 100644
index 00000000..d430ffeb
--- /dev/null
+++ b/packages/platform/migrations/0029_dodo_payments.sql
@@ -0,0 +1,28 @@
+ALTER TABLE platform_payment_providers ADD COLUMN provider TEXT NOT NULL DEFAULT 'custom';
+ALTER TABLE platform_payment_checkouts ADD COLUMN provider TEXT NOT NULL DEFAULT 'creem';
+ALTER TABLE platform_payment_checkouts ADD COLUMN provider_key TEXT REFERENCES platform_payment_providers(id);
+ALTER TABLE platform_payment_checkouts ADD COLUMN environment TEXT NOT NULL DEFAULT 'test';
+ALTER TABLE platform_payment_subscriptions ADD COLUMN provider TEXT NOT NULL DEFAULT 'creem';
+ALTER TABLE platform_payment_subscriptions ADD COLUMN provider_key TEXT REFERENCES platform_payment_providers(id);
+ALTER TABLE platform_payment_subscriptions ADD COLUMN environment TEXT NOT NULL DEFAULT 'test';
+ALTER TABLE platform_payment_events ADD COLUMN provider TEXT NOT NULL DEFAULT 'creem';
+ALTER TABLE platform_payment_events ADD COLUMN provider_key TEXT REFERENCES platform_payment_providers(id);
+ALTER TABLE platform_payment_events ADD COLUMN environment TEXT NOT NULL DEFAULT 'test';
+CREATE TABLE platform_dodo_products(
+ provider_key TEXT NOT NULL REFERENCES platform_payment_providers(id),
+ plan_id TEXT NOT NULL REFERENCES platform_plans(id),
+ interval INTEGER NOT NULL CHECK(interval IN(1,3)),
+ product_id TEXT NOT NULL,
+ price INTEGER NOT NULL,
+ currency TEXT NOT NULL,
+ discount_bps INTEGER NOT NULL DEFAULT 0,
+ effective_price INTEGER NOT NULL,
+ plan_revision INTEGER NOT NULL,
+ credential_revision INTEGER NOT NULL,
+ updated_at INTEGER NOT NULL,
+ PRIMARY KEY(provider_key,plan_id,interval),
+ UNIQUE(provider_key,product_id)
+);
+CREATE INDEX platform_dodo_events_due ON platform_payment_events(provider,environment,state,available_at);
+UPDATE platform_payment_checkouts SET state='expired',error='payment_provider_retired' WHERE provider='creem' AND state IN('creating','open','uncertain');
+CREATE TABLE platform_dodo_sync_locks(provider_key TEXT PRIMARY KEY REFERENCES platform_payment_providers(id),token TEXT NOT NULL,expires_at INTEGER NOT NULL);
diff --git a/packages/platform/migrations/0030_plan_discounts.sql b/packages/platform/migrations/0030_plan_discounts.sql
new file mode 100644
index 00000000..090e419d
--- /dev/null
+++ b/packages/platform/migrations/0030_plan_discounts.sql
@@ -0,0 +1,2 @@
+ALTER TABLE platform_plans ADD COLUMN monthly_discount_bps INTEGER NOT NULL DEFAULT 0 CHECK(monthly_discount_bps BETWEEN 0 AND 9999);
+ALTER TABLE platform_plans ADD COLUMN quarterly_discount_bps INTEGER NOT NULL DEFAULT 0 CHECK(quarterly_discount_bps BETWEEN 0 AND 9999);
diff --git a/packages/platform/package.json b/packages/platform/package.json
index dfdc1673..203c4bdf 100644
--- a/packages/platform/package.json
+++ b/packages/platform/package.json
@@ -14,7 +14,8 @@
},
"dependencies": {
"@chronoframe/contracts": "workspace:*",
- "@chronoframe/core": "workspace:*"
+ "@chronoframe/core": "workspace:*",
+ "dodopayments": "2.59.0"
},
"devDependencies": {
"typescript": "^5.9.3"
diff --git a/packages/platform/src/billing.ts b/packages/platform/src/billing.ts
index 496ccd3c..3c0d1e50 100644
--- a/packages/platform/src/billing.ts
+++ b/packages/platform/src/billing.ts
@@ -1,3 +1,4 @@
+import { discountedPrice } from '../../contracts/src/pricing.ts'
import type { PlatformD1 } from './index.ts'
import {
allRows,
@@ -38,10 +39,26 @@ export function validatePricing(value: unknown) {
Number(p[key]) > 10000000000)
)
throw new SubscriptionError(400, 'invalid_pricing')
+ for (const [priceKey, discountKey] of [
+ ['monthlyPrice', 'monthlyDiscountBps'],
+ ['quarterlyPrice', 'quarterlyDiscountBps'],
+ ] as const) {
+ const discount = p[discountKey] ?? 0
+ if (
+ !Number.isSafeInteger(discount) ||
+ Number(discount) < 0 ||
+ Number(discount) > 9999 ||
+ (Number(p[priceKey]) > 0 &&
+ discountedPrice(Number(p[priceKey]), Number(discount))! < 1)
+ )
+ throw new SubscriptionError(400, 'invalid_pricing')
+ }
return {
currency: p.currency as string,
monthlyPrice: p.monthlyPrice as number | null,
quarterlyPrice: p.quarterlyPrice as number | null,
+ monthlyDiscountBps: Number(p.monthlyDiscountBps ?? 0),
+ quarterlyDiscountBps: Number(p.quarterlyDiscountBps ?? 0),
listed: p.listed,
featured: p.featured as boolean | undefined,
description: p.description,
@@ -56,11 +73,13 @@ export async function pricingCatalog(db: PlatformD1) {
currency: string
monthly_price: number | null
quarterly_price: number | null
+ monthly_discount_bps: number
+ quarterly_discount_bps: number
description: string
featured: number
}>(
db.prepare(
- 'SELECT id,name,policy_json,currency,monthly_price,quarterly_price,description,featured FROM platform_plans WHERE active=1 AND listed=1 ORDER BY sort_order,id',
+ 'SELECT id,name,policy_json,currency,monthly_price,quarterly_price,monthly_discount_bps,quarterly_discount_bps,description,featured FROM platform_plans WHERE active=1 AND listed=1 ORDER BY sort_order,id',
),
)
const settings = await db
@@ -77,11 +96,29 @@ export async function pricingCatalog(db: PlatformD1) {
: 'activation_code',
newPlanId: settings?.new_plan_id ?? 'free',
plans: rows.map(
- ({ policy_json, monthly_price, quarterly_price, featured, ...row }) => ({
+ ({
+ policy_json,
+ monthly_price,
+ quarterly_price,
+ monthly_discount_bps,
+ quarterly_discount_bps,
+ featured,
+ ...row
+ }) => ({
...row,
featured: !!featured,
monthlyPrice: monthly_price,
quarterlyPrice: quarterly_price,
+ monthlyDiscountBps: monthly_discount_bps,
+ quarterlyDiscountBps: quarterly_discount_bps,
+ monthlyEffectivePrice: discountedPrice(
+ monthly_price,
+ monthly_discount_bps,
+ ),
+ quarterlyEffectivePrice: discountedPrice(
+ quarterly_price,
+ quarterly_discount_bps,
+ ),
policy: validatePolicy(JSON.parse(policy_json)),
}),
),
diff --git a/packages/platform/src/dodo-client.ts b/packages/platform/src/dodo-client.ts
new file mode 100644
index 00000000..5b9a0b6e
--- /dev/null
+++ b/packages/platform/src/dodo-client.ts
@@ -0,0 +1,89 @@
+import DodoPayments from 'dodopayments'
+import type { PlatformD1 } from './index.ts'
+import { openProviderCredentials } from './payment-providers.ts'
+import { SubscriptionError } from './subscriptions.ts'
+export type DodoEnvironment = 'test' | 'live'
+export const dodoId = (environment: string, id: string) =>
+ `dodo:${environment}:${id}`
+export const rawDodoId = (id: string) => id.replace(/^dodo:[a-zA-Z0-9_-]+:/, '')
+export function dodoURL(value: unknown, environment: DodoEnvironment) {
+ try {
+ const url = new URL(String(value))
+ if (
+ url.origin !==
+ (environment === 'test'
+ ? 'https://test.checkout.dodopayments.com'
+ : 'https://checkout.dodopayments.com') ||
+ url.username ||
+ url.password
+ )
+ throw Error()
+ return url.href
+ } catch {
+ throw new SubscriptionError(502, 'payment_redirect_invalid')
+ }
+}
+/** Every outbound SDK request rechecks the active environment and payment switch. */
+export async function dodoClient(
+ db: PlatformD1,
+ secret: string,
+ environment: DodoEnvironment,
+ transport: typeof fetch = fetch,
+ purchase = false,
+ expectedId?: string,
+) {
+ const row = await db
+ .prepare(
+ "SELECT p.* FROM platform_payment_providers p JOIN platform_payment_settings s ON s.current_provider=p.id WHERE s.id=1 AND s.enabled=1 AND p.provider='dodo' AND p.environment=? AND (?=0 OR s.purchase_method='payment')",
+ )
+ .bind(environment, purchase ? 1 : 0)
+ .first<any>()
+ if (
+ !row?.credentials_ciphertext ||
+ row.environment !== environment ||
+ (expectedId && row.id !== expectedId)
+ )
+ throw new SubscriptionError(503, 'payment_unavailable')
+ const id = String(row.id)
+ const credentials = await openProviderCredentials(
+ secret,
+ id,
+ environment,
+ row.credentials_ciphertext,
+ )
+ const guardedFetch: typeof fetch = async (input, init) => {
+ const current = await db
+ .prepare(
+ "SELECT p.revision FROM platform_payment_settings s JOIN platform_payment_providers p ON p.id=s.current_provider WHERE s.id=1 AND s.enabled=1 AND p.id=? AND p.revision=? AND (?=0 OR s.purchase_method='payment')",
+ )
+ .bind(id, row.revision, purchase ? 1 : 0)
+ .first()
+ if (!current) throw new SubscriptionError(503, 'payment_unavailable')
+ return transport(input, { ...init, redirect: 'error' })
+ }
+ return {
+ revision: Number(row.revision),
+ key: id,
+ client: new DodoPayments({
+ bearerToken: credentials.apiKey,
+ webhookKey: credentials.webhookSecret,
+ environment: environment === 'test' ? 'test_mode' : 'live_mode',
+ baseURL: null,
+ fetch: guardedFetch,
+ timeout: 10000,
+ maxRetries: 0,
+ logLevel: 'off',
+ }),
+ }
+}
+/** Provider bodies and SDK errors can contain credentials or customer data. */
+export async function dodoRequest<T>(
+ operation: () => PromiseLike<T>,
+): Promise<T> {
+ try {
+ return await operation()
+ } catch (error) {
+ if (error instanceof SubscriptionError) throw error
+ throw new SubscriptionError(502, 'payment_provider_request_failed')
+ }
+}
diff --git a/packages/platform/src/dodo-payments.ts b/packages/platform/src/dodo-payments.ts
new file mode 100644
index 00000000..04a71281
--- /dev/null
+++ b/packages/platform/src/dodo-payments.ts
@@ -0,0 +1,989 @@
+import { discountedPrice } from '../../contracts/src/pricing.ts'
+import { paymentProductSnapshot } from './payment-product-sync.ts'
+import type { PlatformD1 } from './index.ts'
+import {
+ allRows,
+ SubscriptionError,
+ subscriptionInvalidation,
+ EXPIRY_PLAN_SQL,
+} from './subscriptions.ts'
+import { paymentMember, paymentSettings } from './payments.ts'
+import {
+ dodoClient,
+ dodoRequest,
+ dodoId,
+ rawDodoId,
+ dodoURL,
+ type DodoEnvironment,
+} from './dodo-client.ts'
+import { sealPaymentEventPayload } from './payment-events.ts'
+const fail = (code: string, status = 409): never => {
+ throw new SubscriptionError(status, code)
+}
+const identifier = (value: unknown): value is string =>
+ typeof value === 'string' && /^[a-zA-Z0-9_-]{1,160}$/.test(value)
+const timestamp = (value: unknown) =>
+ typeof value === 'string' ? Date.parse(value) : NaN
+async function selectedEnvironment(db: PlatformD1): Promise<DodoEnvironment> {
+ const settings = await paymentSettings(db)
+ if (
+ !settings.enabled ||
+ !settings.providerAvailable ||
+ !settings.configured ||
+ !['test', 'live'].includes(settings.environment ?? '')
+ )
+ fail('payment_unavailable', 503)
+ return settings.environment as DodoEnvironment
+}
+const activeFence =
+ 'EXISTS(SELECT 1 FROM platform_payment_settings s JOIN platform_payment_providers p ON p.id=s.current_provider WHERE s.id=1 AND s.enabled=1 AND p.id=? AND p.revision=?)'
+
+/** Publish immutable price versions; existing subscriptions keep their purchased product. */
+export async function syncDodoProducts(
+ db: PlatformD1,
+ secret: string,
+ transport: typeof fetch = fetch,
+ now = Date.now(),
+ limit = 2,
+) {
+ const settings = await paymentSettings(db)
+ if (!settings.enabled || !settings.providerAvailable || !settings.configured)
+ return { processed: 0 }
+ const environment = settings.environment as DodoEnvironment,
+ key = settings.currentProvider!
+ const { client, revision } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ false,
+ key,
+ )
+ const syncToken = crypto.randomUUID()
+ const syncLock = await db
+ .prepare(
+ 'INSERT INTO platform_dodo_sync_locks(provider_key,token,expires_at) VALUES(?,?,?) ON CONFLICT(provider_key) DO UPDATE SET token=excluded.token,expires_at=excluded.expires_at WHERE expires_at<? RETURNING token',
+ )
+ .bind(key, syncToken, now + 240000, now)
+ .first<any>()
+ if (syncLock?.token !== syncToken) return { processed: 0 }
+ try {
+ const plans = await allRows<any>(
+ db
+ .prepare(
+ 'SELECT p.*,i.period FROM platform_plans p CROSS JOIN (SELECT 1 AS period UNION ALL SELECT 3) i LEFT JOIN platform_dodo_products d ON d.provider_key=? AND d.plan_id=p.id AND d.interval=i.period WHERE p.active=1 AND p.listed=1 AND CASE WHEN i.period=1 THEN p.monthly_price ELSE p.quarterly_price END>0 AND (d.product_id IS NULL OR d.plan_revision<>p.revision OR d.credential_revision<>?) ORDER BY p.sort_order,p.id,i.period LIMIT ?',
+ )
+ .bind(key, revision, limit),
+ )
+ let processed = 0
+ for (const plan of plans) {
+ const price = Number(
+ plan.period === 1 ? plan.monthly_price : plan.quarterly_price,
+ )
+ const snapshot = paymentProductSnapshot(plan, plan.period)
+ const discountBps = Number(
+ plan.period === 1
+ ? plan.monthly_discount_bps
+ : plan.quarterly_discount_bps,
+ )
+ const effectivePrice = discountedPrice(price, discountBps)!
+ if (effectivePrice < 1) fail('payment_price_invalid', 400)
+ const body = {
+ name: snapshot.product.name,
+ description: snapshot.product.description.slice(0, 1000),
+ tax_category: 'saas' as const,
+ price: {
+ type: 'recurring_price' as const,
+ currency: plan.currency,
+ price,
+ payment_frequency_count: plan.period,
+ payment_frequency_interval: 'Month' as const,
+ subscription_period_count: 20,
+ subscription_period_interval: 'Year' as const,
+ tax_inclusive: true,
+ trial_period_days: 0,
+ discount_bps: discountBps,
+ purchasing_power_parity: false,
+ },
+ metadata: {
+ chronoframe_plan_id: plan.id,
+ chronoframe_interval: String(plan.period),
+ chronoframe_profile_id: key,
+ chronoframe_plan_revision: String(plan.revision),
+ },
+ }
+ const product = await dodoRequest(() =>
+ client.products.create(body, {
+ idempotencyKey: `cf-product-${key}-${revision}-${plan.id}-${plan.revision}-${plan.period}`,
+ headers: {
+ 'Idempotency-Key': `cf-product-${key}-${revision}-${plan.id}-${plan.revision}-${plan.period}`,
+ },
+ }),
+ )
+ if (!identifier(product.product_id)) fail('payment_product_invalid', 502)
+ await db
+ .prepare(
+ `INSERT INTO platform_dodo_products(provider_key,plan_id,interval,product_id,price,currency,discount_bps,effective_price,plan_revision,credential_revision,updated_at) SELECT ?,?,?,?,?,?,?,?,?,?,? WHERE ${activeFence} AND EXISTS(SELECT 1 FROM platform_dodo_sync_locks WHERE provider_key=? AND token=? AND expires_at>?) AND EXISTS(SELECT 1 FROM platform_plans WHERE id=? AND revision=?) ON CONFLICT(provider_key,plan_id,interval) DO UPDATE SET product_id=excluded.product_id,price=excluded.price,currency=excluded.currency,discount_bps=excluded.discount_bps,effective_price=excluded.effective_price,plan_revision=excluded.plan_revision,credential_revision=excluded.credential_revision,updated_at=excluded.updated_at`,
+ )
+ .bind(
+ key,
+ plan.id,
+ plan.period,
+ product.product_id,
+ price,
+ plan.currency,
+ discountBps,
+ effectivePrice,
+ plan.revision,
+ revision,
+ now,
+ key,
+ revision,
+ key,
+ syncToken,
+ Date.now(),
+ plan.id,
+ plan.revision,
+ )
+ .run()
+ processed++
+ }
+ return { processed }
+ } finally {
+ await db
+ .prepare(
+ 'DELETE FROM platform_dodo_sync_locks WHERE provider_key=? AND token=?',
+ )
+ .bind(key, syncToken)
+ .run()
+ }
+}
+
+export async function createDodoCheckout(
+ db: PlatformD1,
+ secret: string,
+ userId: number,
+ input: {
+ workspaceId: number
+ planId: string
+ interval: number
+ requestId: string
+ },
+ origin: string,
+ transport: typeof fetch = fetch,
+ now = Date.now(),
+) {
+ const member = await paymentMember(db, userId, input.workspaceId, true)
+ const environment = await selectedEnvironment(db),
+ key = (await paymentSettings(db)).currentProvider!
+ if ((await paymentSettings(db)).purchaseMethod !== 'payment')
+ fail('payment_unavailable', 503)
+ if (
+ !/^[a-zA-Z0-9_.-]{1,128}$/.test(input.planId) ||
+ !identifier(input.requestId) ||
+ ![1, 3].includes(input.interval)
+ )
+ fail('payment_checkout_invalid', 400)
+ const { client, revision } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ true,
+ key,
+ )
+ const existing = await db
+ .prepare(
+ 'SELECT * FROM platform_payment_checkouts WHERE user_id=? AND request_id=?',
+ )
+ .bind(userId, input.requestId)
+ .first<any>()
+ if (existing) {
+ if (
+ existing.workspace_id !== input.workspaceId ||
+ existing.plan_id !== input.planId ||
+ existing.interval !== input.interval ||
+ existing.provider !== 'dodo' ||
+ existing.provider_key !== key ||
+ existing.environment !== environment
+ )
+ fail('payment_request_conflict')
+ if (existing.state === 'open' && existing.checkout_url)
+ return {
+ id: existing.id,
+ url: dodoURL(existing.checkout_url, environment),
+ }
+ fail('payment_confirmation_pending')
+ }
+ const product = await db
+ .prepare(
+ 'SELECT d.* FROM platform_dodo_products d JOIN platform_plans p ON p.id=d.plan_id WHERE d.provider_key=? AND d.plan_id=? AND d.interval=? AND d.credential_revision=? AND d.plan_revision=p.revision AND p.active=1 AND p.listed=1 AND d.price=CASE WHEN d.interval=1 THEN p.monthly_price ELSE p.quarterly_price END AND d.currency=p.currency',
+ )
+ .bind(key, input.planId, input.interval, revision)
+ .first<any>()
+ if (!product) fail('payment_plan_unavailable', 400)
+ const prior = await db
+ .prepare(
+ 'SELECT revision FROM platform_workspace_plans WHERE workspace_id=?',
+ )
+ .bind(input.workspaceId)
+ .first<any>()
+ if (!prior) fail('workspace_unavailable', 404)
+ // Rate limit includes failed attempts, and the partial unique index serializes new sessions per workspace.
+ const budget = await db
+ .prepare(
+ 'INSERT INTO platform_payment_requests(user_id,window_start,attempts) VALUES(?,?,1) ON CONFLICT(user_id,window_start) DO UPDATE SET attempts=attempts+1 RETURNING attempts',
+ )
+ .bind(userId, Math.floor(now / 60000) * 60000)
+ .first<any>()
+ if (budget.attempts > 10) fail('payment_rate_limited', 429)
+ if (
+ await db
+ .prepare(
+ "SELECT id FROM platform_payment_subscriptions WHERE workspace_id=? AND provider='dodo' AND environment=? AND provider_key=? AND status NOT IN('canceled','expired','failed') LIMIT 1",
+ )
+ .bind(input.workspaceId, environment, key)
+ .first()
+ )
+ fail('payment_subscription_exists')
+ const providerProduct = await dodoRequest(() =>
+ client.products.retrieve(product.product_id),
+ )
+ const price = providerProduct.price
+ if (
+ providerProduct.product_id !== product.product_id ||
+ !providerProduct.is_recurring ||
+ price.type !== 'recurring_price' ||
+ price.price !== product.price ||
+ price.currency !== product.currency ||
+ price.payment_frequency_interval !== 'Month' ||
+ price.payment_frequency_count !== input.interval ||
+ !price.tax_inclusive ||
+ (price.trial_period_days ?? 0) !== 0 ||
+ (price.discount_bps ?? (price.discount ?? 0) * 100) !==
+ product.discount_bps ||
+ price.purchasing_power_parity ||
+ providerProduct.addons?.length
+ )
+ fail('payment_product_mismatch', 422)
+ const id = crypto.randomUUID()
+ try {
+ const result = await db
+ .prepare(
+ `INSERT INTO platform_payment_checkouts(id,workspace_id,user_id,request_id,plan_id,interval,product_id,price,currency,assignment_revision,state,created_at,updated_at,provider,environment,provider_key) SELECT ?,?,?,?,?,?,?,?,?,?,'creating',?,?,'dodo',?,? WHERE ${activeFence}`,
+ )
+ .bind(
+ id,
+ input.workspaceId,
+ userId,
+ input.requestId,
+ input.planId,
+ input.interval,
+ product.product_id,
+ product.effective_price,
+ product.currency,
+ prior.revision,
+ now,
+ now,
+ environment,
+ key,
+ key,
+ revision,
+ )
+ .run()
+ if (!result.meta.changes) fail('payment_unavailable', 503)
+ } catch (error) {
+ if (error instanceof SubscriptionError) throw error
+ fail('payment_busy')
+ }
+ try {
+ const session = await dodoRequest(() =>
+ client.checkoutSessions.create(
+ {
+ product_cart: [{ product_id: product.product_id, quantity: 1 }],
+ customer: { email: member.email },
+ metadata: {
+ chronoframe_checkout_id: id,
+ chronoframe_environment: environment,
+ chronoframe_profile_id: key,
+ },
+ return_url: new URL(
+ `/account/plan?checkout=${encodeURIComponent(id)}`,
+ origin,
+ ).href,
+ feature_flags: {
+ allow_currency_selection: false,
+ allow_discount_code: false,
+ allow_customer_editing_email: false,
+ allow_editing_addons: false,
+ },
+ },
+ {
+ idempotencyKey: `cf-checkout-${environment}-${id}`,
+ headers: { 'Idempotency-Key': `cf-checkout-${environment}-${id}` },
+ },
+ ),
+ )
+ if (!identifier(session.session_id)) fail('payment_checkout_invalid', 502)
+ const url = dodoURL(session.checkout_url, environment)
+ await db
+ .prepare(
+ "UPDATE platform_payment_checkouts SET provider_id=?,checkout_url=?,state='open',updated_at=? WHERE id=? AND state='creating'",
+ )
+ .bind(dodoId(key, session.session_id), url, now, id)
+ .run()
+ await dodoClient(db, secret, environment, transport, true, key)
+ return { id, url }
+ } catch {
+ await db
+ .prepare(
+ "UPDATE platform_payment_checkouts SET state='uncertain',error='payment_confirmation_pending',updated_at=? WHERE id=? AND state='creating'",
+ )
+ .bind(now, id)
+ .run()
+ fail('payment_confirmation_pending', 502)
+ }
+}
+
+/** Verify with the official SDK, then durably accept before any provider reads. */
+export async function receiveDodoEvent(
+ db: PlatformD1,
+ secret: string,
+ environment: DodoEnvironment,
+ body: Uint8Array,
+ headers: Record<string, string>,
+ transport: typeof fetch = fetch,
+ now = Date.now(),
+ expectedProfile?: string,
+) {
+ const { client, revision, key } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ false,
+ expectedProfile,
+ )
+ if (body.byteLength > 65536) fail('payment_payload_too_large', 413)
+ let event: any
+ try {
+ event = client.webhooks.unwrap(
+ new TextDecoder('utf-8', { fatal: true }).decode(body),
+ { headers },
+ )
+ } catch {
+ fail('payment_signature_invalid', 401)
+ }
+ const rawId = headers['webhook-id']
+ if (!identifier(rawId) || typeof event?.type !== 'string' || !event.data)
+ fail('payment_event_invalid', 400)
+ const supported =
+ event.type.startsWith('subscription.') ||
+ event.type.startsWith('payment.') ||
+ event.type.startsWith('refund.') ||
+ event.type.startsWith('dispute.')
+ const objectId = event.type.startsWith('subscription.')
+ ? event.data.subscription_id
+ : event.data.payment_id
+ if (!supported || !identifier(objectId)) return { received: true }
+ const id = dodoId(key, rawId!),
+ cipher = await sealPaymentEventPayload(secret, id, body)
+ await db.batch([
+ db
+ .prepare(
+ `INSERT OR IGNORE INTO platform_payment_events(id,type,object_id,reference_id,created_at,available_at,provider,environment,provider_key) SELECT ?,?,?,(SELECT id FROM platform_payment_checkouts WHERE id=? AND provider='dodo' AND environment=? AND provider_key=?),?,?,'dodo',?,? WHERE ${activeFence}`,
+ )
+ .bind(
+ id,
+ event.type,
+ dodoId(key, objectId),
+ String(event.data.metadata?.chronoframe_checkout_id ?? ''),
+ environment,
+ key,
+ now,
+ now,
+ environment,
+ key,
+ key,
+ revision,
+ ),
+ db
+ .prepare(
+ 'INSERT OR IGNORE INTO platform_payment_event_payloads(event_id,ciphertext,received_at) SELECT ?,?,? WHERE EXISTS(SELECT 1 FROM platform_payment_events WHERE id=?)',
+ )
+ .bind(id, cipher, now, id),
+ ])
+ if (
+ !(await db
+ .prepare('SELECT id FROM platform_payment_events WHERE id=?')
+ .bind(id)
+ .first())
+ )
+ fail('payment_unavailable', 503)
+ return { received: true }
+}
+
+/** Read authoritative payment and subscription state; browser and webhook bodies never grant access. */
+async function reconcileDodoSubscription(
+ db: PlatformD1,
+ secret: string,
+ environment: DodoEnvironment,
+ subscriptionId: string,
+ paymentId: string | undefined,
+ transport: typeof fetch,
+ now: number,
+ key: string,
+) {
+ if (!identifier(subscriptionId)) fail('payment_subscription_invalid', 422)
+ const { client, revision } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ false,
+ key,
+ )
+ let subscription = await dodoRequest(() =>
+ client.subscriptions.retrieve(subscriptionId),
+ )
+ const checkoutId = subscription.metadata?.chronoframe_checkout_id
+ if (
+ !identifier(checkoutId) ||
+ subscription.metadata?.chronoframe_environment !== environment ||
+ subscription.metadata?.chronoframe_profile_id !== key
+ )
+ return
+ const checkout = await db
+ .prepare(
+ "SELECT * FROM platform_payment_checkouts WHERE id=? AND provider='dodo' AND environment=? AND provider_key=?",
+ )
+ .bind(checkoutId, environment, key)
+ .first<any>()
+ if (!checkout) return
+ const token = crypto.randomUUID()
+ const lock = await db
+ .prepare(
+ 'INSERT INTO platform_payment_locks(workspace_id,token,expires_at) VALUES(?,?,?) ON CONFLICT(workspace_id) DO UPDATE SET token=excluded.token,expires_at=excluded.expires_at WHERE expires_at<? RETURNING token',
+ )
+ .bind(checkout.workspace_id, token, now + 60000, now)
+ .first<any>()
+ if (lock?.token !== token) fail('payment_busy')
+ try {
+ subscription = await dodoRequest(() =>
+ client.subscriptions.retrieve(subscriptionId),
+ )
+ if (
+ subscription.metadata?.chronoframe_checkout_id !== checkout.id ||
+ subscription.metadata?.chronoframe_environment !== environment ||
+ subscription.metadata?.chronoframe_profile_id !== key
+ )
+ fail('payment_subscription_mismatch', 422)
+ if (
+ subscription.subscription_id !== subscriptionId ||
+ subscription.product_id !== checkout.product_id ||
+ subscription.currency !== checkout.currency ||
+ subscription.quantity !== 1 ||
+ subscription.payment_frequency_interval !== 'Month' ||
+ subscription.payment_frequency_count !== checkout.interval ||
+ subscription.on_demand ||
+ subscription.trial_period_days !== 0
+ )
+ fail('payment_subscription_mismatch', 422)
+ // An initial grant must also be bound to the payment returned by our stored checkout session.
+ const localId = dodoId(key, subscriptionId)
+ const known = await db
+ .prepare('SELECT * FROM platform_payment_subscriptions WHERE id=?')
+ .bind(localId)
+ .first<any>()
+ if (!known && checkout.provider_id) {
+ const session = await dodoRequest(() =>
+ client.checkoutSessions.retrieve(rawDodoId(checkout.provider_id)),
+ )
+ if (
+ session.id !== rawDodoId(checkout.provider_id) ||
+ !session.payment_id ||
+ session.payment_status !== 'succeeded'
+ )
+ fail('payment_confirmation_pending')
+ paymentId = session.payment_id ?? undefined
+ } else if (!known && !paymentId) {
+ const payments = await dodoRequest(() =>
+ client.payments.list({
+ subscription_id: subscriptionId,
+ status: 'succeeded',
+ page_size: 10,
+ }),
+ )
+ paymentId = payments.items.find(
+ (p) => p.metadata?.chronoframe_checkout_id === checkout.id,
+ )?.payment_id
+ }
+ const payment = paymentId
+ ? await dodoRequest(() => client.payments.retrieve(paymentId!))
+ : null
+ const successful =
+ payment?.status === 'succeeded' &&
+ !payment.is_update_payment_method &&
+ !payment.is_multi_subscription &&
+ (payment.subscription_id === subscriptionId ||
+ payment.subscription_ids?.includes(subscriptionId)) &&
+ payment.customer.customer_id === subscription.customer.customer_id &&
+ payment.currency === checkout.currency &&
+ payment.total_amount === checkout.price &&
+ (!payment.metadata?.chronoframe_checkout_id ||
+ payment.metadata.chronoframe_checkout_id === checkout.id) &&
+ (!payment.metadata?.chronoframe_environment ||
+ payment.metadata.chronoframe_environment === environment) &&
+ (!payment.metadata?.chronoframe_profile_id ||
+ payment.metadata.chronoframe_profile_id === key) &&
+ (!!known ||
+ !!checkout.provider_id ||
+ payment.metadata?.chronoframe_checkout_id === checkout.id) &&
+ !payment.refunds?.length &&
+ !payment.disputes?.length
+ const period = successful
+ ? payment.service_periods?.find(
+ (p) => p.subscription_id === subscriptionId,
+ )
+ : null
+ let start = period ? timestamp(period.starts_at) : known?.period_start
+ let end = period ? timestamp(period.ends_at) : known?.period_end
+ if (
+ !Number.isFinite(start) ||
+ !Number.isFinite(end) ||
+ start >= end ||
+ end > now + 110 * 86400000 ||
+ start > now + 60000
+ ) {
+ if (!known) fail('payment_period_invalid', 422)
+ start = known.period_start
+ end = known.period_end
+ }
+ if (known && end < known.period_end) {
+ start = known.period_start
+ end = known.period_end
+ }
+ const status =
+ subscription.status === 'cancelled'
+ ? 'canceled'
+ : subscription.cancel_at_next_billing_date &&
+ subscription.status === 'active'
+ ? 'scheduled_cancel'
+ : subscription.status === 'on_hold' ||
+ subscription.status === 'paused'
+ ? 'past_due'
+ : subscription.status
+ const active =
+ ['active', 'scheduled_cancel', 'past_due'].includes(status) &&
+ end > now &&
+ !(payment && (payment.refunds?.length || payment.disputes?.length))
+ // A failed/refunded payment may revoke but may never extend a paid-through boundary.
+ if (!successful && known) end = known.period_end
+ if (!successful && !known) fail('payment_confirmation_pending')
+ const prior = await db
+ .prepare('SELECT * FROM platform_workspace_plans WHERE workspace_id=?')
+ .bind(checkout.workspace_id)
+ .first<any>()
+ if (
+ await db
+ .prepare(
+ 'SELECT 1 FROM platform_account_deletions WHERE user_id=(SELECT owner_user_id FROM platform_workspaces WHERE id=?)',
+ )
+ .bind(checkout.workspace_id)
+ .first()
+ )
+ fail('payment_account_unavailable')
+ const canAssign = known
+ ? prior?.payment_subscription_id === localId &&
+ ['payment', 'expired_default'].includes(prior.source)
+ : prior?.revision === checkout.assignment_revision ||
+ (prior?.source === 'expired_default' &&
+ prior.revision === checkout.assignment_revision + 1)
+ const anchor = known?.quota_anchor ?? start
+ const eventId = crypto.randomUUID()
+ const fence = `${activeFence} AND EXISTS(SELECT 1 FROM platform_payment_locks WHERE workspace_id=? AND token=?)`
+ const bindFence = [key, revision, checkout.workspace_id, token]
+ const writes = [
+ db
+ .prepare(
+ `INSERT INTO platform_payment_subscriptions(id,workspace_id,checkout_id,customer_id,product_id,plan_id,interval,quota_anchor,status,period_start,period_end,provider_updated_at,checked_at,next_check_at,error,provider,environment,provider_key) SELECT ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,'dodo',?,? WHERE ${fence} ON CONFLICT(id) DO UPDATE SET status=excluded.status,period_start=excluded.period_start,period_end=excluded.period_end,checked_at=excluded.checked_at,next_check_at=excluded.next_check_at,error=excluded.error,revision=platform_payment_subscriptions.revision+1`,
+ )
+ .bind(
+ localId,
+ checkout.workspace_id,
+ checkout.id,
+ subscription.customer.customer_id,
+ checkout.product_id,
+ checkout.plan_id,
+ checkout.interval,
+ anchor,
+ status,
+ start,
+ end,
+ now,
+ now,
+ now + 300000,
+ canAssign ? null : 'payment_grant_superseded',
+ environment,
+ key,
+ ...bindFence,
+ ),
+ db
+ .prepare(
+ `UPDATE platform_payment_checkouts SET state='completed',error=NULL,updated_at=? WHERE id=? AND ${fence}`,
+ )
+ .bind(now, checkout.id, ...bindFence),
+ ]
+ if (
+ canAssign &&
+ (prior.source !== (active ? 'payment' : 'expired_default') ||
+ prior.expires_at !== (active ? end : null) ||
+ (active && prior.plan_id !== checkout.plan_id))
+ ) {
+ writes.push(
+ db
+ .prepare(
+ `INSERT INTO platform_subscription_events(id,workspace_id,kind,before_json,after_json,created_at) SELECT ?,?,'payment',?,?,? WHERE ${fence}`,
+ )
+ .bind(
+ eventId,
+ checkout.workspace_id,
+ JSON.stringify({ planId: prior.plan_id, source: prior.source }),
+ JSON.stringify({
+ provider: 'dodo',
+ environment,
+ subscriptionId: localId,
+ planId: checkout.plan_id,
+ periodEnd: end,
+ }),
+ now,
+ ...bindFence,
+ ),
+ )
+ writes.push(
+ db
+ .prepare(
+ `UPDATE platform_workspace_plans SET plan_id=${active ? '?' : EXPIRY_PLAN_SQL},source=?,starts_at=?,expires_at=?,billing_interval=?,payment_subscription_id=?,revision=revision+1 WHERE workspace_id=? AND revision=? AND EXISTS(SELECT 1 FROM platform_subscription_events WHERE id=?)`,
+ )
+ .bind(
+ ...(active ? [checkout.plan_id] : []),
+ active ? 'payment' : 'expired_default',
+ anchor,
+ active ? end : null,
+ active ? checkout.interval : null,
+ localId,
+ checkout.workspace_id,
+ prior.revision,
+ eventId,
+ ),
+ )
+ writes.push(
+ ...subscriptionInvalidation(db, checkout.workspace_id, eventId),
+ )
+ }
+ await db.batch(writes)
+ return checkout.id as string
+ } finally {
+ await db
+ .prepare(
+ 'DELETE FROM platform_payment_locks WHERE workspace_id=? AND token=?',
+ )
+ .bind(checkout.workspace_id, token)
+ .run()
+ }
+}
+
+export async function processDodoEvents(
+ db: PlatformD1,
+ secret: string,
+ transport: typeof fetch = fetch,
+ now = Date.now(),
+ limit = 5,
+) {
+ const settings = await paymentSettings(db)
+ if (!settings.enabled || !settings.providerAvailable || !settings.configured)
+ return
+ const environment = settings.environment as DodoEnvironment,
+ key = settings.currentProvider!
+ await db
+ .prepare(
+ "UPDATE platform_payment_events SET state='failed',error='payment_attempts_exhausted',lease_token=NULL,lease_until=NULL WHERE provider='dodo' AND environment=? AND provider_key=? AND state='pending' AND attempts>=8 AND (lease_until IS NULL OR lease_until<?)",
+ )
+ .bind(environment, key, now)
+ .run()
+ const events = await allRows<any>(
+ db
+ .prepare(
+ "SELECT * FROM platform_payment_events WHERE provider='dodo' AND environment=? AND provider_key=? AND state='pending' AND attempts<8 AND available_at<=? AND (lease_until IS NULL OR lease_until<?) ORDER BY created_at LIMIT ?",
+ )
+ .bind(environment, key, now, now, limit),
+ )
+ for (const event of events) {
+ const token = crypto.randomUUID()
+ const lease = await db
+ .prepare(
+ "UPDATE platform_payment_events SET lease_token=?,lease_until=?,attempts=attempts+1 WHERE id=? AND state='pending' AND (lease_until IS NULL OR lease_until<?) RETURNING id",
+ )
+ .bind(token, now + 60000, event.id, now)
+ .first()
+ if (!lease) continue
+ try {
+ let reference: string | undefined
+ if (event.type.startsWith('subscription.'))
+ reference = await reconcileDodoSubscription(
+ db,
+ secret,
+ environment,
+ rawDodoId(event.object_id),
+ undefined,
+ transport,
+ now,
+ key,
+ )
+ else {
+ const { client } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ false,
+ key,
+ )
+ const payment = await dodoRequest(() =>
+ client.payments.retrieve(rawDodoId(event.object_id)),
+ )
+ if (payment.subscription_id && !payment.is_multi_subscription)
+ reference = await reconcileDodoSubscription(
+ db,
+ secret,
+ environment,
+ payment.subscription_id,
+ rawDodoId(event.object_id),
+ transport,
+ now,
+ key,
+ )
+ }
+ await db
+ .prepare(
+ "UPDATE platform_payment_events SET state='done',reference_id=COALESCE(?,reference_id),error=NULL,lease_token=NULL,lease_until=NULL WHERE id=? AND lease_token=?",
+ )
+ .bind(reference ?? null, event.id, token)
+ .run()
+ } catch {
+ await db
+ .prepare(
+ "UPDATE platform_payment_events SET state=CASE WHEN attempts>=8 THEN 'failed' ELSE 'pending' END,error='payment_reconciliation_failed',available_at=?,lease_token=NULL,lease_until=NULL WHERE id=? AND lease_token=?",
+ )
+ .bind(
+ now + Math.min(3600000, 30000 * 2 ** event.attempts),
+ event.id,
+ token,
+ )
+ .run()
+ }
+ }
+}
+
+export async function refreshDodoCheckout(
+ db: PlatformD1,
+ secret: string,
+ userId: number,
+ workspaceId: number,
+ checkoutId: string,
+ transport: typeof fetch = fetch,
+ now = Date.now(),
+) {
+ await paymentMember(db, userId, workspaceId, true)
+ const budget = await db
+ .prepare(
+ 'INSERT INTO platform_payment_requests(user_id,window_start,attempts) VALUES(?,?,1) ON CONFLICT(user_id,window_start) DO UPDATE SET attempts=attempts+1 RETURNING attempts',
+ )
+ .bind(userId, Math.floor(now / 60000) * 60000)
+ .first<any>()
+ if (budget.attempts > 20) fail('payment_rate_limited', 429)
+ const environment = await selectedEnvironment(db),
+ key = (await paymentSettings(db)).currentProvider!
+ if (!identifier(checkoutId)) fail('payment_checkout_invalid', 400)
+ const row = await db
+ .prepare(
+ "SELECT * FROM platform_payment_checkouts WHERE id=? AND workspace_id=? AND user_id=? AND provider='dodo' AND environment=? AND provider_key=?",
+ )
+ .bind(checkoutId, workspaceId, userId, environment, key)
+ .first<any>()
+ if (!row) fail('payment_checkout_unavailable', 404)
+ if (!row.provider_id) return { state: row.state }
+ const { client } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ false,
+ key,
+ )
+ const session = await dodoRequest(() =>
+ client.checkoutSessions.retrieve(rawDodoId(row.provider_id)),
+ )
+ if (session.payment_id) {
+ const payment = await dodoRequest(() =>
+ client.payments.retrieve(session.payment_id!),
+ )
+ if (payment.subscription_id && !payment.is_multi_subscription)
+ await reconcileDodoSubscription(
+ db,
+ secret,
+ environment,
+ payment.subscription_id,
+ session.payment_id,
+ transport,
+ now,
+ key,
+ )
+ } else if (now - row.created_at > 86400000)
+ await db
+ .prepare(
+ "UPDATE platform_payment_checkouts SET state='expired',updated_at=? WHERE id=? AND state='open'",
+ )
+ .bind(now, row.id)
+ .run()
+ await db
+ .prepare(
+ "UPDATE platform_payment_checkouts SET updated_at=? WHERE id=? AND state='open'",
+ )
+ .bind(now, row.id)
+ .run()
+ return {
+ state: (
+ await db
+ .prepare('SELECT state FROM platform_payment_checkouts WHERE id=?')
+ .bind(row.id)
+ .first<any>()
+ ).state,
+ }
+}
+export async function reconcileDodoPayments(
+ db: PlatformD1,
+ secret: string,
+ transport: typeof fetch = fetch,
+ now = Date.now(),
+) {
+ const settings = await paymentSettings(db)
+ if (!settings.enabled || !settings.providerAvailable || !settings.configured)
+ return
+ const environment = settings.environment as DodoEnvironment,
+ key = settings.currentProvider!
+ const due = await allRows<any>(
+ db
+ .prepare(
+ "SELECT id FROM platform_payment_subscriptions WHERE provider='dodo' AND environment=? AND provider_key=? AND next_check_at<=? AND status NOT IN('canceled','expired','failed') ORDER BY next_check_at LIMIT 3",
+ )
+ .bind(environment, key, now),
+ )
+ for (const row of due) {
+ try {
+ const { client } = await dodoClient(
+ db,
+ secret,
+ environment,
+ transport,
+ false,
+ key,
+ )
+ const payments = await dodoRequest(() =>
+ client.payments.list({
+ subscription_id: rawDodoId(row.id),
+ status: 'succeeded',
+ page_size: 10,
+ }),
+ )
+ const latest = [...payments.items].sort(
+ (a, b) => timestamp(b.created_at) - timestamp(a.created_at),
+ )[0]
+ await reconcileDodoSubscription(
+ db,
+ secret,
+ environment,
+ rawDodoId(row.id),
+ latest?.payment_id,
+ transport,
+ now,
+ key,
+ )
+ } catch {
+ await db
+ .prepare(
+ "UPDATE platform_payment_subscriptions SET error='payment_reconciliation_failed',next_check_at=? WHERE id=?",
+ )
+ .bind(now + 300000, row.id)
+ .run()
+ }
+ }
+ const pending = await allRows<any>(
+ db
+ .prepare(
+ "SELECT id,workspace_id,user_id FROM platform_payment_checkouts WHERE provider='dodo' AND environment=? AND provider_key=? AND state='open' AND user_id IS NOT NULL ORDER BY updated_at LIMIT 2",
+ )
+ .bind(environment, key),
+ )
+ for (const row of pending)
+ await refreshDodoCheckout(
+ db,
+ secret,
+ row.user_id,
+ row.workspace_id,
+ row.id,
+ transport,
+ now,
+ ).catch(async () => {
+ await db
+ .prepare(
+ "UPDATE platform_payment_checkouts SET updated_at=?,error='payment_reconciliation_failed' WHERE id=? AND state='open'",
+ )
+ .bind(now, row.id)
+ .run()
+ })
+ await processDodoEvents(db, secret, transport, now)
+}
+
+/** Real Dodo subscriptions must be canceled before deleting their local billing ledger. */
+export async function closeDodoAccountPayments(
+ db: PlatformD1,
+ secret: string,
+ userId: number,
+ transport: typeof fetch = fetch,
+) {
+ const rows = await allRows<any>(
+ db
+ .prepare(
+ "SELECT s.* FROM platform_payment_subscriptions s JOIN platform_workspaces w ON w.id=s.workspace_id JOIN platform_payment_checkouts c ON c.id=s.checkout_id WHERE s.provider='dodo' AND (w.owner_user_id=? OR c.user_id=?) AND s.status NOT IN('canceled','expired','failed')",
+ )
+ .bind(userId, userId),
+ )
+ for (const row of rows) {
+ // The normal payment switch also gates account-cleanup provider calls; erasure retries after re-enabling.
+ const { client } = await dodoClient(
+ db,
+ secret,
+ row.environment,
+ transport,
+ false,
+ row.provider_key,
+ )
+ const result = await dodoRequest(() =>
+ client.subscriptions.update(rawDodoId(row.id), { status: 'cancelled' }),
+ )
+ if (result.status !== 'cancelled') return false
+ await db
+ .prepare(
+ "UPDATE platform_payment_subscriptions SET status='canceled',checked_at=? WHERE id=?",
+ )
+ .bind(Date.now(), row.id)
+ .run()
+ }
+ return !(await db
+ .prepare(
+ "SELECT c.id FROM platform_payment_checkouts c JOIN platform_workspaces w ON w.id=c.workspace_id WHERE c.provider='dodo' AND (w.owner_user_id=? OR c.user_id=?) AND c.state IN('creating','open','uncertain') LIMIT 1",
+ )
+ .bind(userId, userId)
+ .first())
+}
diff --git a/packages/platform/src/payment-providers.ts b/packages/platform/src/payment-providers.ts
index 1d1bb81d..0884ba04 100644
--- a/packages/platform/src/payment-providers.ts
+++ b/packages/platform/src/payment-providers.ts
@@ -67,14 +67,21 @@ export async function openProviderCredentials(
export async function paymentProviders(db: PlatformD1) {
const rows = await allRows<any>(
db.prepare(
- 'SELECT id,name,environment,revision,credentials_ciphertext IS NOT NULL AS configured FROM platform_payment_providers ORDER BY id',
+ 'SELECT id,name,provider,environment,revision,credentials_ciphertext IS NOT NULL AS configured FROM platform_payment_providers ORDER BY id',
),
)
return rows.map((row) => ({
...row,
configured: !!row.configured,
- available: false,
- status: row.id === 'creem' ? 'retired' : 'not_integrated',
+ available: row.provider === 'dodo' && !!row.configured,
+ status:
+ row.id === 'creem'
+ ? 'retired'
+ : row.provider === 'dodo'
+ ? row.configured
+ ? 'ready'
+ : 'not_configured'
+ : 'not_integrated',
}))
}
/** Configurations can be prepared before an adapter exists. No unknown provider may execute payments. */
@@ -101,12 +108,26 @@ export async function savePaymentProvider(
throw new SubscriptionError(400, 'payment_provider_invalid')
if (input.id === 'creem')
throw new SubscriptionError(410, 'payment_provider_retired')
+ if (
+ input.provider !== undefined &&
+ !['dodo', 'custom'].includes(input.provider)
+ )
+ throw new SubscriptionError(400, 'payment_provider_invalid')
const prior = await db
.prepare('SELECT * FROM platform_payment_providers WHERE id=?')
.bind(input.id)
.first<any>()
if ((prior?.revision ?? 0) !== input.revision)
throw new SubscriptionError(409, 'payment_revision_conflict')
+ const provider = input.provider ?? prior?.provider ?? 'custom'
+ if (prior && provider !== prior.provider)
+ throw new SubscriptionError(400, 'payment_provider_invalid')
+ if (
+ prior?.credentials_ciphertext &&
+ prior.environment !== input.environment &&
+ provider === 'dodo'
+ )
+ throw new SubscriptionError(400, 'payment_environment_invalid')
let envelope = prior?.credentials_ciphertext ?? null
if (input.credentials !== undefined) {
if (
@@ -123,11 +144,40 @@ export async function savePaymentProvider(
JSON.stringify(input.credentials).length > 12000
)
throw new SubscriptionError(400, 'payment_credentials_invalid')
+ let credentials = input.credentials
+ if (provider === 'dodo') {
+ const saved = envelope
+ ? await openProviderCredentials(
+ secret,
+ input.id,
+ input.environment,
+ envelope,
+ )
+ : {}
+ credentials = {
+ ...saved,
+ ...Object.fromEntries(
+ Object.entries(input.credentials).filter(
+ ([, value]) => typeof value === 'string' && value.trim(),
+ ),
+ ),
+ }
+ if (
+ Object.keys(credentials).some(
+ (key) => !['apiKey', 'webhookSecret'].includes(key),
+ ) ||
+ typeof credentials.apiKey !== 'string' ||
+ !credentials.apiKey.trim() ||
+ typeof credentials.webhookSecret !== 'string' ||
+ !/^whsec_[A-Za-z0-9+/=_-]{16,}$/.test(credentials.webhookSecret)
+ )
+ throw new SubscriptionError(400, 'payment_credentials_invalid')
+ }
envelope = await sealProviderCredentials(
secret,
input.id,
input.environment,
- input.credentials,
+ credentials,
)
} else if (prior && prior.environment !== input.environment && envelope) {
// Preserve credentials while rebinding the authenticated environment context.
@@ -157,6 +207,7 @@ export async function savePaymentProvider(
input.reason.trim(),
JSON.stringify({
name: input.name.trim(),
+ provider,
environment: input.environment,
configured: !!envelope,
}),
@@ -166,7 +217,7 @@ export async function savePaymentProvider(
),
db
.prepare(
- 'INSERT INTO platform_payment_providers(id,name,environment,credentials_ciphertext,updated_at) SELECT ?,?,?,?,? WHERE EXISTS(SELECT 1 FROM platform_admin_audit WHERE id=?) ON CONFLICT(id) DO UPDATE SET name=excluded.name,environment=excluded.environment,credentials_ciphertext=excluded.credentials_ciphertext,updated_at=excluded.updated_at,revision=platform_payment_providers.revision+1',
+ 'INSERT INTO platform_payment_providers(id,name,environment,credentials_ciphertext,updated_at,provider) SELECT ?,?,?,?,?,? WHERE EXISTS(SELECT 1 FROM platform_admin_audit WHERE id=?) ON CONFLICT(id) DO UPDATE SET name=excluded.name,environment=excluded.environment,credentials_ciphertext=excluded.credentials_ciphertext,updated_at=excluded.updated_at,revision=platform_payment_providers.revision+1',
)
.bind(
input.id,
@@ -174,6 +225,7 @@ export async function savePaymentProvider(
input.environment,
envelope,
now,
+ provider,
auditId,
),
])
diff --git a/packages/platform/src/payments.ts b/packages/platform/src/payments.ts
index cb4d3e9c..cce5ad65 100644
--- a/packages/platform/src/payments.ts
+++ b/packages/platform/src/payments.ts
@@ -1,3 +1,8 @@
+import {
+ createDodoCheckout,
+ refreshDodoCheckout,
+ closeDodoAccountPayments,
+} from './dodo-payments.ts'
import type { PlatformD1 } from './index.ts'
import { allRows, SubscriptionError } from './subscriptions.ts'
@@ -79,14 +84,13 @@ export async function paymentSecrets(
export async function paymentSettings(db: PlatformD1) {
const row = await db
.prepare(
- 'SELECT s.current_provider,s.enabled,s.purchase_method,s.revision,s.catalog_revision,s.payload_retention_days,p.environment,p.credentials_ciphertext IS NOT NULL AS configured FROM platform_payment_settings s LEFT JOIN platform_payment_providers p ON p.id=s.current_provider WHERE s.id=1',
+ 'SELECT s.current_provider,s.enabled,s.purchase_method,s.revision,s.catalog_revision,s.payload_retention_days,p.provider,p.environment,p.credentials_ciphertext IS NOT NULL AS configured FROM platform_payment_settings s LEFT JOIN platform_payment_providers p ON p.id=s.current_provider WHERE s.id=1',
)
.first<any>()
return {
enabled: !!row.enabled,
currentProvider: row.current_provider as string | null,
- // No active adapter remains after retiring the Creem sandbox.
- providerAvailable: false,
+ providerAvailable: row.provider === 'dodo',
purchaseMethod: row.purchase_method as 'payment' | 'activation_code',
autoSync: false,
catalogRevision: Number(row.catalog_revision),
@@ -169,30 +173,72 @@ export async function paymentStatus(
purchaseMethod: settings.enabled
? settings.purchaseMethod
: 'activation_code',
- enabled: false,
+ enabled:
+ settings.enabled &&
+ settings.providerAvailable &&
+ settings.configured &&
+ settings.purchaseMethod === 'payment',
canManage: membership.role === 'admin',
- offers: [],
+ offers:
+ settings.enabled &&
+ settings.providerAvailable &&
+ settings.configured &&
+ settings.purchaseMethod === 'payment'
+ ? await allRows<any>(
+ db
+ .prepare(
+ 'SELECT d.plan_id,d.interval FROM platform_dodo_products d JOIN platform_plans p ON p.id=d.plan_id JOIN platform_payment_providers v ON v.id=d.provider_key WHERE d.provider_key=? AND d.credential_revision=v.revision AND d.plan_revision=p.revision AND p.active=1 AND p.listed=1 AND d.price=CASE WHEN d.interval=1 THEN p.monthly_price ELSE p.quarterly_price END AND d.currency=p.currency',
+ )
+ .bind(settings.currentProvider),
+ )
+ : [],
subscriptions,
- pending: null,
+ pending:
+ settings.enabled &&
+ settings.providerAvailable &&
+ settings.purchaseMethod === 'payment'
+ ? await db
+ .prepare(
+ "SELECT id,state,plan_id AS planId,interval,error,CASE WHEN state='open' AND user_id=? AND ?='admin' THEN checkout_url ELSE NULL END AS url FROM platform_payment_checkouts WHERE workspace_id=? AND provider='dodo' AND environment=? AND provider_key=? AND state IN('creating','open','uncertain') ORDER BY created_at DESC LIMIT 1",
+ )
+ .bind(
+ userId,
+ membership.role,
+ workspaceId,
+ settings.environment,
+ settings.currentProvider,
+ )
+ .first<any>()
+ : null,
}
}
-/** Legacy API compatibility: retired checkout operations fail before reading or mutating data. */
+/** Dispatch only the active supported adapter; Creem remains retired. */
export async function createPaymentCheckout(
- _db: PlatformD1,
- _rootKey: string,
- _userId: number,
- _input: {
+ db: PlatformD1,
+ rootKey: string,
+ userId: number,
+ input: {
workspaceId: number
planId: string
interval: number
requestId: string
},
- _portalOrigin: string,
- _transport: PaymentFetch = fetch,
- _now = Date.now(),
+ portalOrigin: string,
+ transport: PaymentFetch = fetch,
+ now = Date.now(),
) {
- throw new SubscriptionError(410, 'payment_provider_retired')
+ if (!(await paymentSettings(db)).providerAvailable)
+ throw new SubscriptionError(410, 'payment_provider_retired')
+ return createDodoCheckout(
+ db,
+ rootKey,
+ userId,
+ input,
+ portalOrigin,
+ transport,
+ now,
+ )
}
export async function createPaymentPortal(
_db: PlatformD1,
@@ -246,25 +292,34 @@ export async function recoverPaymentCheckout(
}
/** Retired sandbox records do not require an upstream cancellation during erasure. */
export async function closeAccountPayments(
- _db: PlatformD1,
- _rootKey: string,
- _userId: number,
- _transport: PaymentFetch = fetch,
+ db: PlatformD1,
+ rootKey: string,
+ userId: number,
+ transport: PaymentFetch = fetch,
) {
- // Historical Creem subscriptions were sandbox-only and cannot bill.
- return true
+ return closeDodoAccountPayments(db, rootKey, userId, transport)
}
-/** Historical return URLs cannot trigger reconciliation or grant access. */
+/** Reconcile only an authenticated local Dodo checkout; browser provider identifiers are ignored. */
export async function refreshPaymentCheckout(
- _db: PlatformD1,
- _rootKey: string,
- _userId: number,
- _workspaceId: number,
- _checkoutId: string,
- _transport: PaymentFetch = fetch,
- _now = Date.now(),
+ db: PlatformD1,
+ rootKey: string,
+ userId: number,
+ workspaceId: number,
+ checkoutId: string,
+ transport: PaymentFetch = fetch,
+ now = Date.now(),
_hints: { providerCheckoutId?: string; subscriptionId?: string } = {},
) {
- throw new SubscriptionError(410, 'payment_provider_retired')
+ if (!(await paymentSettings(db)).providerAvailable)
+ throw new SubscriptionError(410, 'payment_provider_retired')
+ return refreshDodoCheckout(
+ db,
+ rootKey,
+ userId,
+ workspaceId,
+ checkoutId,
+ transport,
+ now,
+ )
}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c49fae4d..12b01d66 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -880,6 +880,9 @@ importers:
'@chronoframe/core':
specifier: workspace:*
version: link:../core
+ dodopayments:
+ specifier: 2.59.0
+ version: 2.59.0
devDependencies:
typescript:
specifier: ^5.9.3
@@ -990,6 +993,19 @@ importers:
packages:
+ '@stablelib/[email protected]':
+ resolution: {integrity: sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==}
+
+ resolution: {integrity: sha512-hJUfgPis3ug1beOgl31rbj7W5A2+WmM3t/JnfTxdLELBuopNe1bV/kGpTgVuLJpRRuQ7fpmGyaJTS0A5/tVh0w==}
+ hasBin: true
+
+ resolution: {integrity: sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==}
+
+ resolution: {integrity: sha512-bCbX9ZEyFkWPsRz7Bl3NuQUJohmwGSev/yhr7vhaGPlc4AfIrspIRa6cPTBuI1ItmrTDJ4d/S2hCsfe4+vQGnQ==}
+
'@adonisjs/[email protected]':
resolution: {integrity: sha512-ZkRguwjAp4skKvKDdRAfdJ2oqQ0N7p9l3sioyXO1E8o0WcsyDgEpsTQtuVNoIdMiw4sn4gJlmL3nyF4BcK1ZDQ==}
engines: {node: '>=20.6.0'}
@@ -10046,6 +10062,19 @@ packages:
snapshots:
+ '@stablelib/[email protected]': {}
+
+ dependencies:
+ standardwebhooks: 1.1.1
+
+
+ dependencies:
+ '@stablelib/base64': 1.0.1
+ fast-sha256: 1.3.0
+
'@adonisjs/[email protected]':
dependencies:
'@phc/format': 1.0.0
diff --git a/tests/dodo-payments.test.ts b/tests/dodo-payments.test.ts
new file mode 100644
index 00000000..8a90fc64
--- /dev/null
+++ b/tests/dodo-payments.test.ts
@@ -0,0 +1,901 @@
+import test from 'node:test'
+import { discountedPrice } from '../packages/contracts/src/pricing.ts'
+import {
+ validatePricing,
+ pricingCatalog,
+} from '../packages/platform/src/billing.ts'
+import assert from 'node:assert/strict'
+import { readFile, readdir } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import {
+ savePaymentProvider,
+ selectPaymentProvider,
+ paymentProviders,
+} from '../packages/platform/src/payment-providers.ts'
+import {
+ paymentSettings,
+ paymentStatus,
+ createPaymentCheckout,
+} from '../packages/platform/src/payments.ts'
+import {
+ syncDodoProducts,
+ receiveDodoEvent,
+ processDodoEvents,
+ refreshDodoCheckout,
+ reconcileDodoPayments,
+} from '../packages/platform/src/dodo-payments.ts'
+import { dodoClient, dodoURL } from '../packages/platform/src/dodo-client.ts'
+const require = createRequire(import.meta.url)
+const { Miniflare, convertV4MiniflareOptions } = createRequire(
+ require.resolve('wrangler/package.json'),
+)('miniflare')
+const root = 'local-dodo-payment-root-key-'.repeat(3),
+ webhookSecret = 'whsec_' + btoa('test-webhook-signing-key-32-bytes!')
+async function fixture() {
+ const mf = new Miniflare(
+ convertV4MiniflareOptions({
+ modules: true,
+ compatibilityDate: '2026-10-26',
+ script: 'export default {fetch(){return new Response("ok")}}',
+ d1Databases: ['DB'],
+ }),
+ ),
+ db = await mf.getD1Database('DB'),
+ now = Date.now()
+ for (const file of (
+ await readdir(new URL('../packages/platform/migrations/', import.meta.url))
+ )
+ .filter((f) => f.endsWith('.sql'))
+ .sort())
+ for (const sql of (
+ await readFile(
+ new URL('../packages/platform/migrations/' + file, import.meta.url),
+ 'utf8',
+ )
+ )
+ .replace(/^--.*$/gm, '')
+ .match(/\s*CREATE TRIGGER[\s\S]+?END;|[^;]+;/g) ?? [])
+ await db.prepare(sql).run()
+ await db
+ .prepare(
+ 'CREATE TABLE platform_admin_audit(id TEXT PRIMARY KEY,actor_id INTEGER,action TEXT,target TEXT,reason TEXT,after_json TEXT,created_at INTEGER)',
+ )
+ .run()
+ await db
+ .prepare(
+ "INSERT INTO platform_users(id,email,name,email_verified,created_at,updated_at) VALUES(1,'[email protected]','Owner',1,?,?),(2,'[email protected]','Other',1,?,?)",
+ )
+ .bind(now, now, now, now)
+ .run()
+ await db
+ .prepare(
+ "INSERT INTO platform_workspaces(id,name,owner_user_id,created_at) VALUES(1,'First',1,?),(2,'Second',2,?)",
+ )
+ .bind(now, now)
+ .run()
+ await db
+ .prepare(
+ "INSERT INTO platform_memberships(workspace_id,user_id,role) VALUES(1,1,'admin'),(2,2,'admin'),(1,2,'member')",
+ )
+ .run()
+ await db
+ .prepare(
+ "INSERT INTO platform_workspace_plans(workspace_id,plan_id,starts_at,source) VALUES(1,'free',?,'default'),(2,'free',?,'default')",
+ )
+ .bind(now, now)
+ .run()
+ await db
+ .prepare(
+ "INSERT INTO platform_plans(id,name,policy_json,currency,monthly_price,quarterly_price) SELECT 'pro','Pro',policy_json,'USD',1200,3000 FROM platform_plans WHERE id='free'",
+ )
+ .run()
+ for (const environment of ['test', 'live'])
+ await savePaymentProvider(db, root, 1, {
+ id: 'dodo_' + environment,
+ name: 'Dodo ' + environment,
+ provider: 'dodo',
+ environment,
+ revision: 0,
+ reason: 'Set up Dodo credentials',
+ credentials: {
+ apiKey: 'api_' + environment,
+ webhookSecret:
+ environment === 'test'
+ ? webhookSecret
+ : 'whsec_' + btoa('production-webhook-signing-key-32'),
+ },
+ })
+ await db
+ .prepare(
+ "UPDATE platform_payment_settings SET enabled=1,current_provider='dodo_test'",
+ )
+ .run()
+ const calls: any[] = [],
+ products = new Map<string, any>(),
+ sessions = new Map<string, any>(),
+ payments = new Map<string, any>(),
+ subscriptions = new Map<string, any>()
+ let createUncertain = false
+ const transport: typeof fetch = async (input, init) => {
+ const url = new URL(
+ typeof input === 'string'
+ ? input
+ : input instanceof URL
+ ? input.href
+ : input.url,
+ ),
+ body = init?.body ? JSON.parse(String(init.body)) : undefined
+ const environment =
+ url.hostname === 'test.dodopayments.com' ? 'test' : 'live'
+ assert.ok(
+ ['test.dodopayments.com', 'live.dodopayments.com'].includes(url.hostname),
+ )
+ assert.equal(
+ new Headers(init?.headers).get('authorization'),
+ 'Bearer api_' + environment,
+ )
+ calls.push({ url: url.href, body, method: init?.method })
+ if (url.pathname === '/products' && init?.method === 'POST') {
+ const product = {
+ ...body,
+ product_id: 'pdt_' + environment + '_' + products.size,
+ is_recurring: true,
+ }
+ products.set(product.product_id, product)
+ return Response.json(product)
+ }
+ if (url.pathname.startsWith('/products/'))
+ return Response.json(products.get(url.pathname.split('/')[2]!))
+ if (url.pathname === '/checkouts' && init?.method === 'POST') {
+ if (createUncertain) throw Error('provider raw secret')
+ const id = 'cks_' + environment + '_' + sessions.size
+ sessions.set(id, {
+ id,
+ metadata: body.metadata,
+ product_id: body.product_cart[0].product_id,
+ payment_id: null,
+ payment_status: null,
+ })
+ return Response.json({
+ session_id: id,
+ checkout_url: `https://${environment === 'test' ? 'test.' : ''}checkout.dodopayments.com/session/${id}`,
+ })
+ }
+ if (url.pathname.startsWith('/checkouts/'))
+ return Response.json(sessions.get(url.pathname.split('/')[2]!))
+ if (url.pathname.startsWith('/subscriptions/'))
+ return Response.json(subscriptions.get(url.pathname.split('/')[2]!))
+ if (url.pathname === '/payments')
+ return Response.json({ items: [...payments.values()] })
+ if (url.pathname.startsWith('/payments/'))
+ return Response.json(payments.get(url.pathname.split('/')[2]!))
+ throw Error('Unexpected request ' + url.href)
+ }
+ async function paid(checkout: any, months = 1) {
+ const id = checkout.url.split('/').pop()!,
+ session = sessions.get(id),
+ product = products.get(session.product_id),
+ start = new Date(now - 1000).toISOString(),
+ end = new Date(now + months * 28 * 86400000).toISOString()
+ const sub = {
+ subscription_id: 'sub_' + id,
+ product_id: product.product_id,
+ currency: 'USD',
+ customer: { customer_id: 'cus_owner' },
+ metadata: session.metadata,
+ status: 'active',
+ quantity: 1,
+ payment_frequency_interval: 'Month',
+ payment_frequency_count: months,
+ on_demand: false,
+ trial_period_days: 0,
+ previous_billing_date: start,
+ next_billing_date: end,
+ cancel_at_next_billing_date: false,
+ }
+ const payment = {
+ payment_id: 'pay_' + id,
+ status: 'succeeded',
+ total_amount: discountedPrice(
+ product.price.price,
+ product.price.discount_bps ?? 0,
+ ),
+ currency: 'USD',
+ customer: sub.customer,
+ metadata: session.metadata,
+ subscription_id: sub.subscription_id,
+ subscription_ids: [sub.subscription_id],
+ service_periods: [
+ {
+ subscription_id: sub.subscription_id,
+ starts_at: start,
+ ends_at: end,
+ },
+ ],
+ refunds: [],
+ disputes: [],
+ created_at: start,
+ is_multi_subscription: false,
+ is_update_payment_method: false,
+ }
+ subscriptions.set(sub.subscription_id, sub)
+ payments.set(payment.payment_id, payment)
+ session.payment_id = payment.payment_id
+ session.payment_status = 'succeeded'
+ return { sub, payment, session }
+ }
+ async function select(environment: string) {
+ const settings = await paymentSettings(db)
+ await selectPaymentProvider(db, 1, {
+ id: 'dodo_' + environment,
+ revision: settings.revision,
+ reason: 'Switch Dodo environment',
+ })
+ }
+ async function sign(type: string, data: any, eventId = 'evt_local') {
+ const body = JSON.stringify({
+ type,
+ data,
+ timestamp: new Date().toISOString(),
+ business_id: 'bus_fixture',
+ }),
+ ts = String(Math.floor(Date.now() / 1000))
+ const key = await crypto.subtle.importKey(
+ 'raw',
+ new TextEncoder().encode(atob(webhookSecret.slice(6))),
+ { name: 'HMAC', hash: 'SHA-256' },
+ false,
+ ['sign'],
+ )
+ const sig = await crypto.subtle.sign(
+ 'HMAC',
+ key,
+ new TextEncoder().encode(eventId + '.' + ts + '.' + body),
+ )
+ return {
+ body: new TextEncoder().encode(body),
+ headers: {
+ 'webhook-id': eventId,
+ 'webhook-timestamp': ts,
+ 'webhook-signature':
+ 'v1,' + btoa(String.fromCharCode(...new Uint8Array(sig))),
+ },
+ }
+ }
+ return {
+ mf,
+ db,
+ now,
+ calls,
+ transport,
+ products,
+ sessions,
+ payments,
+ subscriptions,
+ paid,
+ select,
+ sign,
+ uncertain: () => {
+ createUncertain = true
+ },
+ }
+}
+const input = (requestId = 'request_checkout') => ({
+ workspaceId: 1,
+ planId: 'pro',
+ interval: 1,
+ requestId,
+})
+test('official SDK isolates environments, synchronizes prices and creates a signed-webhook fulfilled checkout', async () => {
+ const f = await fixture()
+ try {
+ assert.equal((await paymentSettings(f.db)).providerAvailable, true)
+ assert.equal((await syncDodoProducts(f.db, root, f.transport)).processed, 2)
+ assert.equal((await syncDodoProducts(f.db, root, f.transport)).processed, 0)
+ assert.equal((await paymentStatus(f.db, 1, 1)).offers.length, 2)
+ const checkout = await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ )
+ assert.match(checkout.url, /test\.checkout\.dodopayments/)
+ assert.deepEqual(
+ await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ ),
+ checkout,
+ )
+ const { sub, payment } = await f.paid(checkout)
+ const event = await f.sign('payment.succeeded', payment)
+ await assert.rejects(
+ receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ { ...event.headers, 'webhook-signature': 'v1,bad' },
+ f.transport,
+ ),
+ { code: 'payment_signature_invalid' },
+ )
+ await receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ )
+ await receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ )
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ "SELECT COUNT(*) AS n FROM platform_payment_events WHERE provider='dodo'",
+ )
+ .first<any>()
+ ).n,
+ 1,
+ )
+ const stored = await f.db
+ .prepare('SELECT ciphertext FROM platform_payment_event_payloads')
+ .first<any>()
+ assert.ok(!stored.ciphertext.includes('cus_owner'))
+ await processDodoEvents(f.db, root, f.transport)
+ const grant = await f.db
+ .prepare('SELECT * FROM platform_workspace_plans WHERE workspace_id=1')
+ .first<any>()
+ assert.equal(grant.plan_id, 'pro')
+ assert.equal(
+ grant.payment_subscription_id,
+ 'dodo:dodo_test:' + sub.subscription_id,
+ )
+ const events = (
+ await f.db
+ .prepare('SELECT COUNT(*) AS n FROM platform_subscription_events')
+ .first<any>()
+ ).n
+ await reconcileDodoPayments(f.db, root, f.transport, f.now + 400000)
+ assert.equal(
+ (
+ await f.db
+ .prepare('SELECT COUNT(*) AS n FROM platform_subscription_events')
+ .first<any>()
+ ).n,
+ events,
+ )
+ await f.select('live')
+ assert.equal((await paymentStatus(f.db, 1, 1)).offers.length, 0)
+ await assert.rejects(
+ receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ ),
+ { code: 'payment_unavailable' },
+ )
+ await syncDodoProducts(f.db, root, f.transport)
+ assert.ok(
+ f.calls.some((c) => c.url.startsWith('https://live.dodopayments.com')),
+ )
+ assert.equal(
+ (
+ await f.db
+ .prepare('SELECT COUNT(*) AS n FROM platform_dodo_products')
+ .first<any>()
+ ).n,
+ 4,
+ )
+ assert.equal(
+ (await paymentProviders(f.db)).filter((p) => p.available).length,
+ 2,
+ )
+ } finally {
+ await f.mf.dispose()
+ }
+})
+test('Dodo switch, purchase mode, membership and mid-flight shutdown prevent provider calls or grants', async () => {
+ const f = await fixture()
+ try {
+ await syncDodoProducts(f.db, root, f.transport)
+ await assert.rejects(
+ createPaymentCheckout(
+ f.db,
+ root,
+ 2,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ ),
+ { code: 'workspace_admin_required' },
+ )
+ await f.db
+ .prepare(
+ "UPDATE platform_payment_settings SET purchase_method='activation_code'",
+ )
+ .run()
+ let before = f.calls.length
+ await assert.rejects(
+ createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ ),
+ { code: 'payment_unavailable' },
+ )
+ assert.equal(f.calls.length, before)
+ await f.db
+ .prepare("UPDATE platform_payment_settings SET purchase_method='payment'")
+ .run()
+ const checkout = await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ )
+ const { payment } = await f.paid(checkout),
+ event = await f.sign('payment.succeeded', payment)
+ const { client } = await dodoClient(f.db, root, 'test', f.transport)
+ await f.db.prepare('UPDATE platform_payment_settings SET enabled=0').run()
+ before = f.calls.length
+ await syncDodoProducts(f.db, root, f.transport)
+ await reconcileDodoPayments(f.db, root, f.transport)
+ await processDodoEvents(f.db, root, f.transport)
+ await assert.rejects(
+ receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ ),
+ { code: 'payment_unavailable' },
+ )
+ await assert.rejects(client.products.list())
+ assert.equal(f.calls.length, before)
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ 'SELECT plan_id FROM platform_workspace_plans WHERE workspace_id=1',
+ )
+ .first<any>()
+ ).plan_id,
+ 'free',
+ )
+ assert.throws(
+ () => dodoURL('https://test.checkout.dodopayments.com/session/x', 'live'),
+ { code: 'payment_redirect_invalid' },
+ )
+ await assert.rejects(
+ savePaymentProvider(f.db, root, 1, {
+ id: 'dodo_test',
+ name: 'Dodo',
+ environment: 'live',
+ revision: 1,
+ reason: 'Invalid environment change',
+ }),
+ { code: 'payment_environment_invalid' },
+ )
+ } finally {
+ await f.mf.dispose()
+ }
+})
+test('authoritative returns, renewals, cancellation and superseding grants never trust browser identifiers', async () => {
+ const f = await fixture()
+ try {
+ await syncDodoProducts(f.db, root, f.transport)
+ const checkout = await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ )
+ await assert.rejects(
+ refreshDodoCheckout(f.db, root, 2, 1, checkout.id, f.transport),
+ { code: 'workspace_admin_required' },
+ )
+ const { sub, payment } = await f.paid(checkout)
+ assert.equal(
+ (await refreshDodoCheckout(f.db, root, 1, 1, checkout.id, f.transport))
+ .state,
+ 'completed',
+ )
+ const first = await f.db
+ .prepare('SELECT * FROM platform_workspace_plans WHERE workspace_id=1')
+ .first<any>()
+ const renewed = {
+ ...payment,
+ payment_id: 'pay_renewed',
+ metadata: {},
+ created_at: new Date(f.now + 1000).toISOString(),
+ service_periods: [
+ {
+ subscription_id: sub.subscription_id,
+ starts_at: payment.service_periods[0].ends_at,
+ ends_at: new Date(f.now + 56 * 86400000).toISOString(),
+ },
+ ],
+ }
+ f.payments.set(renewed.payment_id, renewed)
+ let event = await f.sign('payment.succeeded', renewed, 'evt_renewal')
+ await receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ )
+ await processDodoEvents(f.db, root, f.transport, f.now + 28 * 86400000)
+ const renewal = await f.db
+ .prepare('SELECT * FROM platform_workspace_plans WHERE workspace_id=1')
+ .first<any>()
+ assert.ok(renewal.expires_at > first.expires_at)
+ assert.equal(renewal.starts_at, first.starts_at)
+ await f.db
+ .prepare(
+ "UPDATE platform_workspace_plans SET plan_id='free',source='manual',revision=revision+1 WHERE workspace_id=1",
+ )
+ .run()
+ sub.status = 'cancelled'
+ event = await f.sign('subscription.cancelled', sub, 'evt_cancelled')
+ await receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ )
+ await processDodoEvents(f.db, root, f.transport)
+ const manual = await f.db
+ .prepare('SELECT * FROM platform_workspace_plans WHERE workspace_id=1')
+ .first<any>()
+ assert.equal(manual.source, 'manual')
+ assert.equal(manual.plan_id, 'free')
+ } finally {
+ await f.mf.dispose()
+ }
+})
+test('ambiguous SDK checkout creation is never repeated; stale catalog snapshots cannot create a session', async () => {
+ const f = await fixture()
+ try {
+ await syncDodoProducts(f.db, root, f.transport)
+ await f.db
+ .prepare(
+ "UPDATE platform_plans SET monthly_price=1300,name='Pro Updated',description='Updated entitlements',revision=revision+1 WHERE id='pro'",
+ )
+ .run()
+ await assert.rejects(
+ createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ ),
+ { code: 'payment_plan_unavailable' },
+ )
+ await syncDodoProducts(f.db, root, f.transport)
+ assert.ok(
+ [...f.products.values()].some(
+ (p) =>
+ p.name.includes('Pro Updated') &&
+ p.description.includes('Updated entitlements') &&
+ p.price.price === 1300,
+ ),
+ )
+ assert.ok([...f.products.values()].some((p) => p.price.price === 1200))
+ f.uncertain()
+ await assert.rejects(
+ createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ ),
+ { code: 'payment_confirmation_pending' },
+ )
+ const before = f.calls.length
+ await assert.rejects(
+ createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ ),
+ { code: 'payment_confirmation_pending' },
+ )
+ assert.equal(f.calls.length, before)
+ } finally {
+ await f.mf.dispose()
+ }
+})
+
+test('wrong amounts cannot grant access and authoritative refunds revoke only the linked paid grant', async () => {
+ const f = await fixture()
+ try {
+ await syncDodoProducts(f.db, root, f.transport)
+ assert.match([...f.products.values()][0].description, /Platform storage:/)
+ const checkout = await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ )
+ const { payment } = await f.paid(checkout)
+ const amount = payment.total_amount
+ payment.total_amount = 1
+ await assert.rejects(
+ refreshDodoCheckout(f.db, root, 1, 1, checkout.id, f.transport),
+ )
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ 'SELECT plan_id FROM platform_workspace_plans WHERE workspace_id=1',
+ )
+ .first<any>()
+ ).plan_id,
+ 'free',
+ )
+ payment.total_amount = amount
+ await refreshDodoCheckout(f.db, root, 1, 1, checkout.id, f.transport)
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ 'SELECT plan_id FROM platform_workspace_plans WHERE workspace_id=1',
+ )
+ .first<any>()
+ ).plan_id,
+ 'pro',
+ )
+ payment.refunds.push({ status: 'succeeded' } as never)
+ const event = await f.sign(
+ 'refund.succeeded',
+ { payment_id: payment.payment_id },
+ 'evt_refund',
+ )
+ await receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ )
+ await processDodoEvents(f.db, root, f.transport)
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ 'SELECT source FROM platform_workspace_plans WHERE workspace_id=1',
+ )
+ .first<any>()
+ ).source,
+ 'expired_default',
+ )
+ } finally {
+ await f.mf.dispose()
+ }
+})
+
+test('default discounts use basis points in Dodo, public pricing and the immutable checkout amount', async () => {
+ const f = await fixture()
+ try {
+ const pricing = validatePricing({
+ currency: 'USD',
+ monthlyPrice: 1200,
+ quarterlyPrice: 3000,
+ monthlyDiscountBps: 2000,
+ quarterlyDiscountBps: 1000,
+ listed: true,
+ description: 'Discounted Pro',
+ sortOrder: 1,
+ })
+ assert.equal(pricing.monthlyDiscountBps, 2000)
+ assert.throws(
+ () => validatePricing({ ...pricing, monthlyDiscountBps: 10000 }),
+ { code: 'invalid_pricing' },
+ )
+ assert.throws(
+ () => validatePricing({ ...pricing, monthlyDiscountBps: 0.5 }),
+ { code: 'invalid_pricing' },
+ )
+ assert.equal(discountedPrice(2399, 1000), 2159)
+ await f.db
+ .prepare(
+ "UPDATE platform_plans SET monthly_discount_bps=2000,quarterly_discount_bps=1000,revision=revision+1 WHERE id='pro'",
+ )
+ .run()
+ await syncDodoProducts(f.db, root, f.transport)
+ const product = [...f.products.values()].find(
+ (p) => p.price.payment_frequency_count === 1,
+ )
+ assert.equal(product.price.price, 1200)
+ assert.equal(product.price.discount_bps, 2000)
+ const catalog = await pricingCatalog(f.db),
+ plan = catalog.plans.find((p) => p.id === 'pro')!
+ assert.equal(plan.monthlyPrice, 1200)
+ assert.equal(plan.monthlyDiscountBps, 2000)
+ assert.equal(plan.monthlyEffectivePrice, 960)
+ assert.equal(plan.quarterlyEffectivePrice, 2700)
+ const checkout = await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ )
+ assert.equal(
+ (
+ await f.db
+ .prepare('SELECT price FROM platform_payment_checkouts WHERE id=?')
+ .bind(checkout.id)
+ .first<any>()
+ ).price,
+ 960,
+ )
+ await f.paid(checkout)
+ await refreshDodoCheckout(f.db, root, 1, 1, checkout.id, f.transport)
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ 'SELECT plan_id FROM platform_workspace_plans WHERE workspace_id=1',
+ )
+ .first<any>()
+ ).plan_id,
+ 'pro',
+ )
+ await f.db
+ .prepare(
+ "UPDATE platform_plans SET monthly_discount_bps=1000,revision=revision+1 WHERE id='pro'",
+ )
+ .run()
+ await syncDodoProducts(f.db, root, f.transport)
+ assert.ok(
+ [...f.products.values()].some((p) => p.price.discount_bps === 2000),
+ )
+ assert.equal(
+ (
+ await f.db
+ .prepare('SELECT price FROM platform_payment_checkouts WHERE id=?')
+ .bind(checkout.id)
+ .first<any>()
+ ).price,
+ 960,
+ )
+ } finally {
+ await f.mf.dispose()
+ }
+})
+test('multiple named Dodo profiles in one environment isolate callbacks, products and secrets', async () => {
+ const f = await fixture()
+ try {
+ await syncDodoProducts(f.db, root, f.transport)
+ const checkout = await createPaymentCheckout(
+ f.db,
+ root,
+ 1,
+ input(),
+ 'https://portal.example',
+ f.transport,
+ )
+ const { payment } = await f.paid(checkout),
+ event = await f.sign('payment.succeeded', payment)
+ await savePaymentProvider(f.db, root, 1, {
+ id: 'second_merchant',
+ name: 'Second merchant test',
+ provider: 'dodo',
+ environment: 'test',
+ revision: 0,
+ reason: 'Add another Dodo profile',
+ credentials: { apiKey: 'api_test', webhookSecret },
+ })
+ const settings = await paymentSettings(f.db)
+ await selectPaymentProvider(f.db, 1, {
+ id: 'second_merchant',
+ revision: settings.revision,
+ reason: 'Switch merchant configuration',
+ })
+ await assert.rejects(
+ receiveDodoEvent(
+ f.db,
+ root,
+ 'test',
+ event.body,
+ event.headers,
+ f.transport,
+ Date.now(),
+ 'dodo_test',
+ ),
+ { code: 'payment_unavailable' },
+ )
+ assert.equal((await paymentStatus(f.db, 1, 1)).offers.length, 0)
+ await syncDodoProducts(f.db, root, f.transport)
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ "SELECT COUNT(*) AS n FROM platform_dodo_products WHERE provider_key='second_merchant'",
+ )
+ .first<any>()
+ ).n,
+ 2,
+ )
+ assert.equal(
+ (
+ await f.db
+ .prepare(
+ "SELECT COUNT(*) AS n FROM platform_dodo_products WHERE provider_key='dodo_test'",
+ )
+ .first<any>()
+ ).n,
+ 2,
+ )
+ await savePaymentProvider(f.db, root, 1, {
+ id: 'second_merchant',
+ name: 'Renamed merchant',
+ provider: 'dodo',
+ environment: 'test',
+ revision: 1,
+ reason: 'Rotate the API key only',
+ credentials: { apiKey: 'api_test' },
+ })
+ assert.equal(
+ (await paymentProviders(f.db)).find((p) => p.id === 'second_merchant')!
+ .configured,
+ true,
+ )
+ await assert.rejects(
+ savePaymentProvider(f.db, root, 1, {
+ id: 'second_merchant',
+ name: 'Invalid move',
+ provider: 'dodo',
+ environment: 'live',
+ revision: 2,
+ reason: 'Attempt environment change',
+ }),
+ { code: 'payment_environment_invalid' },
+ )
+ } finally {
+ await f.mf.dispose()
+ }
+})
diff --git a/tests/portal-review-regressions.test.ts b/tests/portal-review-regressions.test.ts
index b8b91da8..566a70a9 100644
--- a/tests/portal-review-regressions.test.ts
+++ b/tests/portal-review-regressions.test.ts
@@ -315,7 +315,7 @@ test('Overview data stays unknown before the first response and retains counts d
assert.equal(media.albums.value.length, 1)
})
-test('Retired payment scheduler only runs local retention and never exposes raw errors', async () => {
+test('Dodo scheduler isolates provider failures and local retention without exposing raw errors', async () => {
let scheduled: any
const calls: string[] = [],
logs: string[] = []
@@ -326,6 +326,16 @@ test('Retired payment scheduler only runs local retention and never exposes raw
console: { error: (code: string) => logs.push(code) },
},
{
+ '../../../../packages/platform/src/dodo-payments': {
+ syncDodoProducts: async () => {
+ calls.push('dodo-sync')
+ throw new Error('sensitive fixture')
+ },
+ reconcileDodoPayments: async () => {
+ calls.push('dodo-reconcile')
+ throw new Error('sensitive fixture')
+ },
+ },
'../../../../packages/platform/src/payment-product-sync': {
syncPaymentProducts: async () => {
calls.push('sync')
@@ -353,10 +363,14 @@ test('Retired payment scheduler only runs local retention and never exposes raw
},
})
await scheduled({ env: { DB: {}, NUXT_PLATFORM_STORAGE_SECRET: 'fixture' } })
- assert.deepEqual(calls, ['expiry'])
- assert.deepEqual(logs, ['payment_payload_expiry_failed'])
+ assert.deepEqual(calls, ['dodo-sync', 'dodo-reconcile', 'expiry'])
+ assert.deepEqual(logs, [
+ 'dodo_product_sync_failed',
+ 'dodo_reconciliation_failed',
+ 'payment_payload_expiry_failed',
+ ])
await scheduled({ env: {} })
- assert.deepEqual(calls, ['expiry'])
+ assert.deepEqual(calls, ['dodo-sync', 'dodo-reconcile', 'expiry'])
})
test('Primary billing workspace consistently prefers ownership then administrative membership', async () => {