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
import type { PlatformD1 } from './index.ts'
import { allRows, SubscriptionError } from './subscriptions.ts'
import { paymentMember, paymentSettings } from './payments.ts'
import {
dodoClient,
dodoRequest,
rawDodoId,
DodoProviderError,
} from './dodo-client.ts'
const invalid = (code: string, status = 409): never => {
throw new SubscriptionError(status, code)
}
export async function paymentPlanRules(db: PlatformD1) {
return allRows<any>(
db.prepare(
'SELECT r.*,a.name AS from_name,b.name AS to_name FROM platform_payment_plan_rules r JOIN platform_plans a ON a.id=r.from_plan JOIN platform_plans b ON b.id=r.to_plan ORDER BY a.sort_order,b.sort_order,a.id,b.id',
),
)
}
export async function savePaymentPlanRule(
db: PlatformD1,
actor: number,
input: any,
now = Date.now(),
) {
if (
typeof input.fromPlan !== 'string' ||
typeof input.toPlan !== 'string' ||
input.fromPlan === input.toPlan ||
!['upgrade', 'downgrade'].includes(input.direction) ||
typeof input.enabled !== 'boolean' ||
!Number.isSafeInteger(input.revision) ||
input.revision < 0 ||
typeof input.reason !== 'string' ||
input.reason.trim().length < 5 ||
input.reason.length > 500
)
invalid('payment_change_rule_invalid', 400)
const plans = await allRows<any>(
db
.prepare(
'SELECT id FROM platform_plans WHERE id IN(?,?) AND active=1 AND listed=1 AND (monthly_price>0 OR quarterly_price>0)',
)
.bind(input.fromPlan, input.toPlan),
)
if (input.enabled && plans.length !== 2)
invalid('payment_change_rule_invalid', 400)
const before = await db
.prepare(
'SELECT * FROM platform_payment_plan_rules WHERE from_plan=? AND to_plan=?',
)
.bind(input.fromPlan, input.toPlan)
.first<any>()
if ((before?.revision ?? 0) !== input.revision) invalid('revision_conflict')
const id = crypto.randomUUID()
const guard =
input.revision === 0
? 'NOT EXISTS(SELECT 1 FROM platform_payment_plan_rules WHERE from_plan=? AND to_plan=?)'
: 'EXISTS(SELECT 1 FROM platform_payment_plan_rules WHERE from_plan=? AND to_plan=? AND revision=?)'
const values = [
input.fromPlan,
input.toPlan,
...(input.revision ? [input.revision] : []),
]
const result = await db.batch([
db
.prepare(
`INSERT INTO platform_admin_audit(id,actor_id,action,target,reason,after_json,created_at) SELECT ?,?,'payment.plan-rule',?,?,?,? WHERE ${guard}`,
)
.bind(
id,
actor,
input.fromPlan + ':' + input.toPlan,
input.reason.trim(),
JSON.stringify({
from: input.fromPlan,
to: input.toPlan,
direction: input.direction,
enabled: input.enabled,
}),
now,
...values,
),
db
.prepare(
'INSERT INTO platform_payment_plan_rules(from_plan,to_plan,direction,enabled) SELECT ?,?,?,? WHERE EXISTS(SELECT 1 FROM platform_admin_audit WHERE id=?) ON CONFLICT(from_plan,to_plan) DO UPDATE SET direction=excluded.direction,enabled=excluded.enabled,revision=platform_payment_plan_rules.revision+1',
)
.bind(
input.fromPlan,
input.toPlan,
input.direction,
input.enabled ? 1 : 0,
id,
),
])
if (!result[0]?.meta?.changes) invalid('revision_conflict')
return { saved: true }
}
const mode = (direction: string) =>
direction === 'upgrade'
? {
proration_billing_mode: 'prorated_immediately_keep_cycle' as const,
effective_at: 'immediately' as const,
}
: {
proration_billing_mode: 'full_immediately' as const,
effective_at: 'next_billing_date' as const,
}
async function validateTarget(
client: Awaited<ReturnType<typeof dodoClient>>['client'],
target: any,
) {
const product = await dodoRequest(() =>
client.products.retrieve(target.product_id),
)
const price = product.price
if (
product.product_id !== target.product_id ||
!product.is_recurring ||
price.type !== 'recurring_price' ||
price.price !== target.price ||
price.currency !== target.currency ||
price.payment_frequency_count !== target.interval ||
price.payment_frequency_interval !== 'Month' ||
!price.tax_inclusive ||
(price.discount_bps ?? (price.discount ?? 0) * 100) !==
target.discount_bps ||
price.purchasing_power_parity ||
(price.trial_period_days ?? 0) !== 0 ||
product.addons?.length
)
invalid('payment_product_mismatch', 422)
}
async function context(
db: PlatformD1,
secret: string,
user: number,
workspace: number,
transport: typeof fetch,
) {
await paymentMember(db, user, workspace, true)
const settings = await paymentSettings(db)
if (
!settings.enabled ||
!settings.providerAvailable ||
!settings.configured ||
settings.purchaseMethod !== 'payment'
)
invalid('payment_unavailable', 503)
const sub = await db
.prepare(
"SELECT s.* FROM platform_payment_subscriptions s JOIN platform_workspace_plans w ON w.payment_subscription_id=s.id AND w.workspace_id=s.workspace_id WHERE s.workspace_id=? AND s.provider='dodo' AND s.provider_key=? AND s.environment=? AND s.status='active' AND s.period_end>? AND w.source='payment'",
)
.bind(workspace, settings.currentProvider, settings.environment, Date.now())
.first<any>()
if (!sub) invalid('payment_active_subscription_required')
const provider = await dodoClient(
db,
secret,
settings.environment as 'test' | 'live',
transport,
true,
settings.currentProvider!,
)
return { sub, ...provider }
}
export async function previewPaymentPlanChange(
db: PlatformD1,
secret: string,
user: number,
input: { workspaceId: number; planId: string },
transport: typeof fetch = fetch,
now = Date.now(),
) {
const { sub, client, key, revision } = await context(
db,
secret,
user,
input.workspaceId,
transport,
)
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(user, Math.floor(now / 60000) * 60000)
.first<any>()
if (budget.attempts > 10) invalid('payment_rate_limited', 429)
if (
await db
.prepare(
"SELECT id FROM platform_payment_plan_changes WHERE workspace_id=? AND state IN('submitting','pending','scheduled','uncertain')",
)
.bind(input.workspaceId)
.first()
)
invalid('payment_change_pending')
const rule = await db
.prepare(
'SELECT * FROM platform_payment_plan_rules WHERE from_plan=? AND to_plan=? AND enabled=1',
)
.bind(sub.plan_id, input.planId)
.first<any>()
if (!rule) invalid('payment_change_not_allowed', 403)
const target = await db
.prepare(
'SELECT d.*,p.revision 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.plan_revision=p.revision AND d.credential_revision=? AND p.active=1 AND p.listed=1 AND d.effective_price>0 AND d.currency=?',
)
.bind(key, input.planId, sub.interval, revision, sub.currency)
.first<any>()
if (!target) invalid('payment_plan_unavailable')
await validateTarget(client, target)
const actual = await dodoRequest(() =>
client.subscriptions.retrieve(rawDodoId(sub.id)),
)
if (
actual.product_id !== sub.product_id ||
actual.status !== 'active' ||
actual.cancel_at_next_billing_date ||
actual.scheduled_change ||
actual.customer.customer_id !== sub.customer_id
)
invalid('payment_subscription_changed')
const params = {
product_id: target.product_id,
quantity: 1,
...mode(rule.direction),
on_payment_failure: 'prevent_change' as const,
}
const quote = await dodoRequest(() =>
client.subscriptions.previewChangePlan(rawDodoId(sub.id), params),
)
if (
quote.new_plan.product_id !== target.product_id ||
quote.new_plan.quantity !== 1 ||
!Number.isSafeInteger(quote.immediate_charge.summary.total_amount)
)
invalid('payment_quote_invalid', 502)
const id = crypto.randomUUID()
await db
.prepare(
"INSERT INTO platform_payment_plan_changes(id,workspace_id,user_id,subscription_id,provider_key,credential_revision,from_product,from_plan,to_product,to_plan,interval,price,currency,direction,rule_revision,plan_revision,subscription_revision,quote_json,state,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,'quoted',?,?)",
)
.bind(
id,
input.workspaceId,
user,
sub.id,
key,
revision,
sub.product_id,
sub.plan_id,
target.product_id,
target.plan_id,
target.interval,
target.effective_price,
target.currency,
rule.direction,
rule.revision,
target.revision,
sub.revision,
JSON.stringify(quote.immediate_charge),
now,
now,
)
.run()
return {
id,
direction: rule.direction,
planId: target.plan_id,
interval: target.interval,
renewalAmount:
quote.new_plan.tax_inclusive === true &&
quote.new_plan.currency === target.currency &&
Number.isSafeInteger(quote.new_plan.recurring_pre_tax_amount) &&
quote.new_plan.recurring_pre_tax_amount >= 0
? quote.new_plan.recurring_pre_tax_amount
: target.effective_price,
currency: target.currency,
charge: quote.immediate_charge.summary,
effectiveAt: quote.immediate_charge.effective_at,
expiresAt: now + 600000,
}
}
export async function commitPaymentPlanChange(
db: PlatformD1,
secret: string,
user: number,
workspace: number,
id: string,
transport: typeof fetch = fetch,
now = Date.now(),
) {
const { sub, client, key, revision } = await context(
db,
secret,
user,
workspace,
transport,
)
const row = await db
.prepare(
'SELECT * FROM platform_payment_plan_changes WHERE id=? AND workspace_id=? AND user_id=? AND subscription_id=? AND provider_key=?',
)
.bind(id, workspace, user, sub.id, key)
.first<any>()
if (!row) invalid('payment_change_unavailable', 404)
if (row.state === 'failed') invalid('payment_change_failed')
if (row.state !== 'quoted') return { state: row.state }
if (
row.created_at < now - 600000 ||
row.credential_revision !== revision ||
row.subscription_revision !== sub.revision ||
row.from_product !== sub.product_id
)
invalid('payment_quote_expired')
const actual = await dodoRequest(() =>
client.subscriptions.retrieve(rawDodoId(sub.id)),
)
if (
actual.product_id !== sub.product_id ||
actual.status !== 'active' ||
actual.cancel_at_next_billing_date ||
actual.scheduled_change ||
actual.customer.customer_id !== sub.customer_id
)
invalid('payment_subscription_changed')
const target = await db
.prepare(
'SELECT * FROM platform_dodo_products WHERE provider_key=? AND product_id=? AND plan_revision=? AND credential_revision=?',
)
.bind(key, row.to_product, row.plan_revision, revision)
.first<any>()
if (!target) invalid('payment_quote_expired')
await validateTarget(client, target)
const changed = await db
.prepare(
"UPDATE platform_payment_plan_changes SET state='submitting',updated_at=? WHERE id=? AND state='quoted' AND EXISTS(SELECT 1 FROM platform_payment_plan_rules WHERE from_plan=? AND to_plan=? AND enabled=1 AND revision=?) AND EXISTS(SELECT 1 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.product_id=? AND d.plan_revision=p.revision AND p.revision=? AND d.credential_revision=? AND p.active=1 AND p.listed=1) AND EXISTS(SELECT 1 FROM platform_payment_settings s JOIN platform_payment_providers p ON p.id=s.current_provider WHERE s.enabled=1 AND s.purchase_method='payment' AND p.id=? AND p.revision=?) AND EXISTS(SELECT 1 FROM platform_payment_subscriptions s JOIN platform_workspace_plans w ON w.payment_subscription_id=s.id AND w.source='payment' WHERE s.id=? AND s.revision=? AND s.product_id=?)",
)
.bind(
now,
id,
row.from_plan,
row.to_plan,
row.rule_revision,
key,
row.to_plan,
row.interval,
row.to_product,
row.plan_revision,
revision,
key,
revision,
sub.id,
sub.revision,
sub.product_id,
)
.run()
.catch(() => invalid('payment_change_pending'))
if (!changed.meta.changes) invalid('payment_quote_expired')
try {
await dodoRequest(() =>
client.subscriptions.changePlan(
rawDodoId(sub.id),
{
product_id: row.to_product,
quantity: 1,
...mode(row.direction),
on_payment_failure: 'prevent_change',
metadata: { ...actual.metadata, chronoframe_change_id: id },
},
{ headers: { 'Idempotency-Key': `cf-change-${id}` } },
),
)
const state = row.direction === 'downgrade' ? 'scheduled' : 'pending'
await db
.prepare(
"UPDATE platform_payment_plan_changes SET state=?,updated_at=? WHERE id=? AND state='submitting'",
)
.bind(state, now, id)
.run()
await db
.prepare(
'UPDATE platform_payment_subscriptions SET next_check_at=0 WHERE id=?',
)
.bind(sub.id)
.run()
await checkPaymentPlanChange(
db,
secret,
user,
workspace,
transport,
now,
).catch(() => undefined)
const latest = await db
.prepare('SELECT state FROM platform_payment_plan_changes WHERE id=?')
.bind(id)
.first<any>()
return { state: latest.state }
} catch (error) {
// An ambiguous response may already have charged the saved payment method. Never resend it.
await db
.prepare(
"UPDATE platform_payment_plan_changes SET state=?,updated_at=? WHERE id=? AND state='submitting'",
)
.bind(
error instanceof DodoProviderError &&
[400, 401, 403, 404, 422].includes(error.providerStatus ?? 0)
? 'failed'
: 'uncertain',
now,
id,
)
.run()
throw error
}
}
export async function checkPaymentPlanChange(
db: PlatformD1,
secret: string,
user: number,
workspace: number,
transport: typeof fetch = fetch,
now = Date.now(),
) {
await paymentMember(db, user, workspace, true)
const settings = await paymentSettings(db)
const row = await db
.prepare(
"SELECT s.* FROM platform_payment_subscriptions s JOIN platform_payment_plan_changes c ON c.subscription_id=s.id WHERE c.workspace_id=? AND c.provider_key=? AND c.state IN('submitting','pending','scheduled','uncertain') ORDER BY c.created_at DESC LIMIT 1",
)
.bind(workspace, settings.currentProvider)
.first<any>()
if (!row) return { state: 'idle' }
const { reconcileDodoSubscription } = await import('./dodo-payments.ts')
await reconcileDodoSubscription(
db,
secret,
row.environment,
rawDodoId(row.id),
undefined,
transport,
now,
row.provider_key,
)
return { checked: true }
}