Self-hosted personal gallery application with online photo management and albums, supporting Live/Motion Photos, EXIF parsing, geolocation recognition, and an explore map.
TypeScript albumsexif-extractiongeocodinglive-photomotion-photophoto-galleryphoto-sharingwebgl-viewer
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.vueindex 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.readyconst 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) === 0diff --git a/apps/cloud/app/composables/useDodoCheckoutReturn.ts b/apps/cloud/app/composables/useDodoCheckoutReturn.tsnew file mode 100644index 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.vueindex 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 } =billingconst 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><CfCardv-if="error || listError"role="alert"diff --git a/apps/cloud/i18n/locales/en.json b/apps/cloud/i18n/locales/en.jsonindex 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.jsonindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.sqlnew file mode 100644index 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.sqlnew file mode 100644index 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.jsonindex 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.tsindex 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: stringmonthly_price: number | nullquarterly_price: number | null+ monthly_discount_bps: number+ quarterly_discount_bps: numberdescription: stringfeatured: 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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 ?? nullif (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.tsindex 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: numberplanId: stringinterval: numberrequestId: 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.yamlindex 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.0devDependencies: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++ [email protected]: {}++ dependencies:+ '@stablelib/base64': 1.0.1+ fast-sha256: 1.3.0+'@adonisjs/[email protected]':dependencies:'@phc/format': 1.0.0diff --git a/tests/dodo-payments.test.ts b/tests/dodo-payments.test.tsnew file mode 100644index 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.tsindex 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 dassert.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: anyconst calls: string[] = [],logs: string[] = []@@ -326,6 +326,16 @@ test('Retired payment scheduler only runs local retention and never exposes rawconsole: { 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 () => {