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 { domainEligibility } from './domain-policy.ts'
import { workspaceEntitlements } from './entitlements.ts'
import {
DEFAULT_CNAME_TARGET,
DEFAULT_SITE_BASE,
defaultSiteHost,
domainClaimTarget,
normalizeDomain,
validSiteSlug,
} from '@chronoframe/contracts/domains'
import type { CustomDomain, DomainStatus } from '@chronoframe/contracts/domains'
import type { PlatformD1, D1Statement } from './index.ts'
export class DomainError extends Error {
statusCode: number
code: string
constructor(statusCode: number, code: string) {
super(code)
this.statusCode = statusCode
this.code = code
}
}
export interface DomainProvider {
count(): Promise<number>
find(
hostname: string,
): Promise<{ id: string; status: string; ssl: string } | null>
create(hostname: string): Promise<{ id: string; status: string; ssl: string }>
get(id: string): Promise<{ id: string; status: string; ssl: string } | null>
retry(id: string): Promise<void>
remove(id: string): Promise<void>
findRoute(hostname: string): Promise<{ id: string; owned: boolean } | null>
createRoute(hostname: string): Promise<string>
removeRoute(id: string, hostname: string): Promise<void>
}
export type DnsState = 'ready' | 'missing' | 'unknown'
export interface DomainConfig {
baseDomain: string
cnameTarget: string
enabled: boolean
routingReady: boolean
limit: number
}
export const DOMAIN_HEALTH_TTL = 60 * 60 * 1000
const PENDING_LIMIT = 10
const HAS_PROVIDER =
'(provider_attempted=1 OR provider_id IS NOT NULL OR route_attempted=1 OR route_id IS NOT NULL)'
const CLAIM_TTL = 48 * 60 * 60 * 1000
interface Row {
hostname: string
site_id: number
generation: string
revision: number
state: DomainStatus
dns_status: CustomDomain['dnsStatus']
provider_id: string | null
route_id: string | null
provider_attempted: number
route_attempted: number
hostname_status: string
ssl_status: string
error: string | null
is_primary: number
redirects: number
created_at: number
checked_at: number | null
expires_at: number
next_check_at: number
attempts: number
lease_token: string | null
retry_requested: number
lease_until: number | null
verified_at: number | null
user_paused: number
hold_reason: string | null
purge_requested: number
restore_primary: number
}
export function domainDTO(
row: Row,
target = DEFAULT_CNAME_TARGET,
): CustomDomain {
return {
hostname: row.hostname,
siteId: row.site_id,
generation: row.generation,
cnameTarget: domainClaimTarget(row.generation, target),
revision: row.revision,
status: row.state,
dnsStatus: row.dns_status,
hostnameStatus: row.hostname_status,
sslStatus: row.ssl_status,
error: row.error,
primary: !!row.is_primary,
redirects: !!row.redirects,
createdAt: row.created_at,
checkedAt: row.checked_at,
expiresAt: row.expires_at,
nextCheckAt: row.next_check_at,
holdReason: row.hold_reason as CustomDomain['holdReason'],
cleanupPending:
!!(
row.provider_id ||
row.route_id ||
row.provider_attempted ||
row.route_attempted
) &&
(row.state === 'paused' || row.state === 'deleting'),
}
}
/** Domain transitions retain their generation and database lease through external retries. */
export function createDomainManager(
db: PlatformD1,
config: DomainConfig,
dependencies: {
dns(host: string, target: string): Promise<DnsState>
provider: DomainProvider
id(): string
now?(): number
},
) {
const now = dependencies.now ?? Date.now
const stmt = (sql: string, ...args: (string | number | null)[]) =>
db.prepare(sql).bind(...args)
const base = normalizeDomain(config.baseDomain || DEFAULT_SITE_BASE)
const target = normalizeDomain(config.cnameTarget || DEFAULT_CNAME_TARGET)
const resourceLimit = Math.max(1, Math.min(config.limit, 20))
const memberGuard = `EXISTS(SELECT 1 FROM platform_sites s JOIN platform_memberships m ON m.workspace_id=s.workspace_id WHERE s.id=? AND s.suspended=0 AND m.user_id=? AND m.role='admin')`
async function authorize(userId: number, siteId: number, admin = true) {
const row = await stmt(
`SELECT s.id,s.slug,s.revision,m.role FROM platform_sites s JOIN platform_memberships m ON m.workspace_id=s.workspace_id WHERE s.id=? AND s.suspended=0 AND m.user_id=?`,
siteId,
userId,
).first<{ id: number; slug: string; revision: number; role: string }>()
if (!row) throw new DomainError(404, 'domain_not_found')
if (admin && row.role !== 'admin')
throw new DomainError(403, 'domain_admin_required')
return row
}
function audit(
siteId: number,
hostname: string,
generation: string,
action: string,
userId: number | null,
guard: string,
args: (string | number | null)[],
): D1Statement {
return stmt(
`INSERT INTO platform_domain_audit(site_id,hostname,generation,action,user_id,created_at) SELECT ?,?,?,?,?,? WHERE EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard})`,
siteId,
hostname,
generation,
action,
userId,
now(),
...args,
)
}
async function list(userId: number, siteId: number) {
await authorize(userId, siteId, false)
const rows = await stmt(
`SELECT json_group_array(json_object('hostname',hostname,'site_id',site_id,'generation',generation,'revision',revision,'state',state,'dns_status',dns_status,'hostname_status',hostname_status,'ssl_status',ssl_status,'error',error,'is_primary',is_primary,'redirects',redirects,'created_at',created_at,'checked_at',checked_at,'expires_at',expires_at,'next_check_at',next_check_at,'user_paused',user_paused,'hold_reason',hold_reason,'provider_attempted',provider_attempted,'route_attempted',route_attempted,'provider_id',provider_id,'route_id',route_id)) AS items FROM (SELECT * FROM platform_custom_domains WHERE site_id=? AND state<>'deleted' ORDER BY created_at)`,
siteId,
).first<{ items: string }>()
return Promise.all(
(JSON.parse(rows?.items ?? '[]') as Row[]).map(async (row) => {
const eligibility = await domainEligibility(db, row.hostname)
const dto = domainDTO(row, target)
if (!['deleting', 'expired'].includes(row.state)) {
dto.holdReason = row.user_paused ? 'manual' : eligibility.reason
if (!eligibility.allowed || row.user_paused) {
dto.status = 'paused'
dto.cleanupPending = !!(
row.provider_id ||
row.route_id ||
row.provider_attempted ||
row.route_attempted
)
} else if (row.state === 'paused') {
dto.status = 'pending'
dto.holdReason = null
}
}
return dto
}),
)
}
async function request(userId: number, siteId: number, input: unknown) {
await authorize(userId, siteId)
if (!config.enabled) throw new DomainError(503, 'domain_unavailable')
let host: string
try {
host = normalizeDomain(input)
} catch {
throw new DomainError(400, 'domain_invalid')
}
if (
host === DEFAULT_SITE_BASE ||
host.endsWith('.' + DEFAULT_SITE_BASE) ||
host === base ||
host.endsWith('.' + base) ||
host === target ||
host.endsWith('.workers.dev')
)
throw new DomainError(400, 'domain_reserved')
const mapping = await stmt(
'SELECT site_id FROM platform_domains WHERE hostname=?',
host,
).first<{ site_id: number }>()
if (mapping && mapping.site_id !== siteId)
throw new DomainError(409, 'domain_conflict')
const existing = await stmt(
'SELECT * FROM platform_custom_domains WHERE hostname=?',
host,
).first<Row>()
if (existing && existing.state !== 'deleted') {
if (existing.site_id !== siteId)
throw new DomainError(409, 'domain_conflict')
return domainDTO(existing, target)
}
if (existing && (existing.provider_id || existing.route_id))
throw new DomainError(409, 'domain_cleanup_pending')
const workspace = await stmt(
'SELECT workspace_id FROM platform_sites WHERE id=?',
siteId,
).first<{ workspace_id: number }>()
const plan = await workspaceEntitlements(db, workspace!.workspace_id)
if (!plan.limits.customDomains) throw new DomainError(403, 'domain_limit')
const generation = dependencies.id(),
time = now()
try {
const insertion = stmt(
`INSERT INTO platform_custom_domains(hostname,site_id,generation,created_at,expires_at,next_check_at,dns_status)
SELECT ?,?,?,?,?,?,? WHERE ${memberGuard}
AND (SELECT COUNT(*) FROM platform_custom_domains WHERE state NOT IN('deleted','paused') AND NOT ${HAS_PROVIDER})<?
AND (SELECT COUNT(*) FROM platform_custom_domains WHERE state<>'deleted' AND (state<>'paused' OR ${HAS_PROVIDER}))<?
AND (SELECT COUNT(*) FROM platform_custom_domains c JOIN platform_sites s ON s.id=c.site_id WHERE s.workspace_id=(SELECT workspace_id FROM platform_sites WHERE id=?) AND c.state<>'deleted')<?
ON CONFLICT(hostname) DO UPDATE SET site_id=excluded.site_id,generation=excluded.generation,revision=platform_custom_domains.revision+1,state='pending',created_at=excluded.created_at,expires_at=excluded.expires_at,next_check_at=excluded.next_check_at,dns_status=excluded.dns_status,provider_attempted=0,route_attempted=0,retry_requested=0,attempts=0,checked_at=NULL,verified_at=NULL,hostname_status='unknown',ssl_status='unknown',error=NULL,is_primary=0,redirects=0,lease_token=NULL,lease_until=NULL,user_paused=0,hold_reason=NULL,purge_requested=0,restore_primary=0
WHERE platform_custom_domains.state='deleted' AND platform_custom_domains.provider_id IS NULL AND platform_custom_domains.route_id IS NULL`,
host,
siteId,
generation,
time,
time + CLAIM_TTL,
time,
'missing',
siteId,
userId,
PENDING_LIMIT,
resourceLimit + PENDING_LIMIT,
siteId,
plan.limits.customDomains,
)
await db.batch([
insertion,
audit(
siteId,
host,
generation,
'requested',
userId,
'hostname=? AND generation=?',
[host, generation],
),
])
const result = await stmt(
'SELECT * FROM platform_custom_domains WHERE hostname=? AND generation=?',
host,
generation,
).first<Row>()
if (!result) {
const concurrent = await stmt(
'SELECT * FROM platform_custom_domains WHERE hostname=?',
host,
).first<Row>()
if (
concurrent &&
concurrent.site_id === siteId &&
concurrent.state !== 'deleted'
)
return domainDTO(concurrent, target)
if (concurrent) throw new DomainError(409, 'domain_conflict')
throw new DomainError(429, 'domain_limit')
}
return domainDTO(result, target)
} catch (error) {
if (String(error).includes('UNIQUE constraint'))
throw new DomainError(409, 'domain_conflict')
throw error
}
}
async function mutate(
userId: number,
siteId: number,
host: string,
generation: string,
revision: number,
action: 'pause' | 'resume' | 'delete' | 'check' | 'primary' | 'redirects',
value = false,
) {
await authorize(userId, siteId)
if (!Number.isSafeInteger(revision) || revision < 1)
throw new DomainError(400, 'domain_invalid')
const row = await stmt(
'SELECT * FROM platform_custom_domains WHERE hostname=? AND site_id=? AND generation=?',
host,
siteId,
generation,
).first<Row>()
if (!row || row.state === 'deleted')
throw new DomainError(404, 'domain_not_found')
if (row.revision !== revision) throw new DomainError(409, 'domain_changed')
if (
(action === 'primary' || action === 'redirects') &&
(row.state !== 'active' ||
!row.verified_at ||
row.verified_at < now() - DOMAIN_HEALTH_TTL)
)
throw new DomainError(409, 'domain_not_ready')
if (row.state === 'deleting' && action !== 'delete')
throw new DomainError(409, 'domain_cleanup_pending')
if (
['resume', 'primary', 'redirects'].includes(action) &&
!(await domainEligibility(db, host)).allowed
)
throw new DomainError(403, 'domain_limit')
if (action === 'resume' && row.state !== 'paused')
throw new DomainError(409, 'domain_changed')
if (action === 'check' && row.next_check_at > now() + 30000)
throw new DomainError(429, 'domain_wait')
const guard = `hostname=? AND site_id=? AND generation=? AND revision=? AND ${memberGuard}${action === 'primary' || action === 'redirects' ? ` AND state='active' AND verified_at>=${now() - DOMAIN_HEALTH_TTL}` : ''}`
const args = [host, siteId, generation, revision, siteId, userId]
const statements: D1Statement[] = [
audit(siteId, host, generation, action, userId, guard, args),
]
if (action === 'primary')
statements.push(
stmt(
`UPDATE platform_custom_domains SET is_primary=0,restore_primary=0 WHERE site_id=? AND hostname<>? AND EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard})`,
siteId,
host,
...args,
),
)
let set =
action === 'pause'
? "state='paused',is_primary=0,user_paused=1,hold_reason='manual',restore_primary=0"
: action === 'delete'
? "state='deleting',is_primary=0,restore_primary=0"
: action === 'resume'
? "state='pending',is_primary=0,user_paused=0,hold_reason=NULL"
: action === 'primary'
? 'is_primary=1,restore_primary=0'
: action === 'redirects'
? `redirects=${value ? 1 : 0}`
: 'error=NULL,retry_requested=1'
if (action === 'pause' || action === 'delete' || action === 'resume')
statements.push(
stmt(
`UPDATE platform_domains SET active=0 WHERE hostname=? AND site_id=? AND EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard})`,
host,
siteId,
...args,
),
)
statements.push(
stmt(
`UPDATE platform_custom_domains SET ${set},revision=revision+1,next_check_at=? WHERE ${guard}`,
now(),
...args,
),
)
const results = await db.batch(statements)
if (results.at(-1)?.meta.changes !== 1)
throw new DomainError(409, 'domain_changed')
return { ok: true }
}
/** Claim only a bounded due batch; API checks and scheduled checks share the lease. */
async function reconcile(onlyHost?: string, batchSize = 5) {
if (!config.enabled) return { checked: 0 }
const rows = await stmt(
`SELECT json_group_array(hostname) AS items FROM (SELECT hostname FROM platform_custom_domains WHERE (state IN ('pending','active','deleting','expired') OR (state='deleted' AND purge_requested=1) OR (state='paused' AND ((hold_reason IS NOT NULL AND hold_reason<>'manual') OR provider_attempted=1 OR route_attempted=1 OR (verified_at IS NULL AND expires_at<=?)))) AND next_check_at<=? AND (lease_until IS NULL OR lease_until<?) ${onlyHost ? 'AND hostname=?' : ''} ORDER BY CASE WHEN ${HAS_PROVIDER} THEN 0 WHEN next_check_at=0 THEN 1 WHEN state='pending' THEN 2 ELSE 3 END,next_check_at,hostname LIMIT ?)`,
now(),
now(),
now(),
...(onlyHost ? [onlyHost] : []),
Math.max(1, Math.min(5, Math.floor(batchSize))),
).first<{ items: string }>()
let checked = 0
for (const host of JSON.parse(rows?.items ?? '[]') as string[]) {
const token = dependencies.id(),
time = now()
const row = await stmt(
`UPDATE platform_custom_domains SET lease_token=?,lease_until=? WHERE hostname=? AND (lease_until IS NULL OR lease_until<?) AND next_check_at<=? AND (state IN ('pending','active','deleting','expired') OR (state='deleted' AND purge_requested=1) OR (state='paused' AND ((hold_reason IS NOT NULL AND hold_reason<>'manual') OR provider_attempted=1 OR route_attempted=1 OR (verified_at IS NULL AND expires_at<=?)))) RETURNING *`,
token,
time + 300000,
host,
time,
time,
time,
).first<Row>()
if (!row) continue
const epoch = await stmt(
'SELECT revision FROM platform_policy_epoch WHERE id=1',
).first<{ revision: number }>()
const guard =
'hostname=? AND generation=? AND lease_token=? AND revision=? AND state=? AND (SELECT revision FROM platform_policy_epoch WHERE id=1)=?'
const args = [
host,
row.generation,
token,
row.revision,
row.state,
epoch!.revision,
]
const fenced = async (
sql: string,
...values: (string | number | null)[]
) => {
const result = await stmt(
`UPDATE platform_custom_domains SET ${sql} WHERE ${guard}`,
...values,
...args,
).run()
if (result.meta.changes !== 1)
throw new DomainError(409, 'domain_changed')
}
const complete = async (statements: D1Statement[], action?: string) => {
const results = await db.batch([
...(action
? [
audit(
row.site_id,
host,
row.generation,
action,
null,
guard,
args,
),
]
: []),
...statements,
])
if (results.at(-1)?.meta.changes !== 1)
throw new DomainError(409, 'domain_changed')
}
try {
const eligibility = await domainEligibility(db, host)
const expired =
(row.state === 'pending' || row.state === 'paused') &&
time >= row.expires_at &&
!row.verified_at
const deleting =
row.state === 'deleting' ||
(row.state === 'deleted' && row.purge_requested === 1) ||
row.state === 'expired' ||
expired
const hold = row.user_paused ? 'manual' : eligibility.reason
if (deleting || hold) {
if (
!deleting &&
row.state === 'paused' &&
row.hold_reason === hold &&
!row.provider_id &&
!row.route_id &&
!row.provider_attempted &&
!row.route_attempted &&
!row.is_primary
) {
await fenced(
'checked_at=?,next_check_at=?,lease_token=NULL,lease_until=NULL',
time,
time + 1800000,
)
checked++
continue
}
// Delete only resources owned by this claim, recovering IDs after uncertain writes.
let providerId = row.provider_id,
routeId = row.route_id
if (!providerId && row.provider_attempted)
providerId = (await dependencies.provider.find(host))?.id ?? null
if (!routeId && row.route_attempted) {
const route = await dependencies.provider.findRoute(host)
if (route && !route.owned)
throw new DomainError(409, 'domain_provider_conflict')
routeId = route?.id ?? null
}
if (routeId) await dependencies.provider.removeRoute(routeId, host)
if (providerId) await dependencies.provider.remove(providerId)
await complete(
[
stmt(
`DELETE FROM platform_domains WHERE hostname=? AND site_id=? AND kind='custom' AND EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard})`,
host,
row.site_id,
...args,
),
stmt(
`UPDATE platform_custom_domains SET revision=revision+1,state=?,restore_primary=CASE WHEN ?=0 AND user_paused=0 THEN MAX(restore_primary,is_primary) ELSE 0 END,is_primary=0,provider_id=NULL,route_id=NULL,provider_attempted=0,route_attempted=0,hold_reason=?,hostname_status='removed',ssl_status='removed',error=NULL,checked_at=?,next_check_at=?,lease_token=NULL,lease_until=NULL WHERE ${guard}`,
deleting ? 'deleted' : 'paused',
deleting ? 1 : 0,
deleting ? null : hold,
time,
deleting && row.purge_requested
? time
: time + (deleting ? 86400000 : 1800000),
...args,
),
],
deleting ? 'removed' : 'suspended',
)
if (deleting && row.purge_requested)
await stmt(
"DELETE FROM platform_custom_domains WHERE hostname=? AND generation=? AND state='deleted' AND provider_id IS NULL AND route_id IS NULL AND provider_attempted=0 AND route_attempted=0",
host,
row.generation,
).run()
checked++
continue
}
if (row.state === 'deleted') continue
const dns = await dependencies.dns(
host,
domainClaimTarget(row.generation, target),
)
if (dns === 'unknown')
throw new DomainError(503, 'domain_dns_unavailable')
if (dns === 'missing') {
await complete([
stmt(
`UPDATE platform_domains SET active=0 WHERE hostname=? AND site_id=? AND EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard})`,
host,
row.site_id,
...args,
),
stmt(
`UPDATE platform_custom_domains SET revision=revision+1,state='pending',is_primary=0,dns_status=?,checked_at=?,next_check_at=?,error=NULL,lease_token=NULL,lease_until=NULL WHERE ${guard}`,
'missing',
time,
time + 30000,
...args,
),
])
checked++
continue
}
let provider = row.provider_id
? await dependencies.provider.get(row.provider_id)
: await dependencies.provider.find(host)
if (!row.provider_id && provider && !row.provider_attempted)
throw new DomainError(409, 'domain_provider_conflict')
if (row.provider_id && !provider) {
if (row.route_id)
await dependencies.provider.removeRoute(row.route_id, host)
await fenced('provider_id=NULL,route_id=NULL,route_attempted=0')
row.route_id = null
row.route_attempted = 0
row.provider_id = null
}
if (!provider) {
const allocationToken = dependencies.id()
const allocation = await stmt(
'UPDATE platform_domain_provider_lock SET lease_token=?,lease_until=? WHERE id=1 AND (lease_until IS NULL OR lease_until<?)',
allocationToken,
now() + 300000,
now(),
).run()
if (allocation.meta.changes !== 1)
throw new DomainError(429, 'domain_wait')
try {
const reserved = await stmt(
`SELECT COUNT(*) AS n FROM platform_custom_domains WHERE state<>'deleted' AND hostname<>? AND ${HAS_PROVIDER}`,
host,
).first<{ n: number }>()
if (
(reserved?.n ?? resourceLimit) >= resourceLimit ||
(await dependencies.provider.count()) >= resourceLimit
)
throw new DomainError(429, 'domain_limit')
await fenced('provider_attempted=1')
provider = await dependencies.provider.create(host)
} finally {
await stmt(
'UPDATE platform_domain_provider_lock SET lease_token=NULL,lease_until=NULL WHERE id=1 AND lease_token=?',
allocationToken,
).run()
}
}
if (row.retry_requested && row.provider_id) {
await dependencies.provider.retry(row.provider_id)
provider = await dependencies.provider.get(row.provider_id)
if (!provider) throw new DomainError(409, 'domain_provider_missing')
await fenced('retry_requested=0')
}
await fenced(
"provider_id=?,hostname_status=?,ssl_status=?,dns_status='ready'",
provider.id,
provider.status,
provider.ssl,
)
let routeId = row.route_id
if (
provider.status === 'active' &&
provider.ssl === 'active' &&
config.routingReady
) {
const route = await dependencies.provider.findRoute(host)
if (route && !route.owned)
throw new DomainError(409, 'domain_provider_conflict')
if (!routeId && route && !row.route_attempted)
throw new DomainError(409, 'domain_provider_conflict')
if (routeId && (!route || route.id !== routeId))
throw new DomainError(409, 'domain_provider_missing')
if (!routeId) {
await fenced('route_attempted=1')
routeId =
route?.id ?? (await dependencies.provider.createRoute(host))
}
await fenced('route_id=?', routeId)
}
const active =
provider.status === 'active' &&
provider.ssl === 'active' &&
!!routeId &&
config.routingReady
await complete(
[
stmt(
`INSERT INTO platform_domains(hostname,site_id,verified,active,kind) SELECT ?,?,1,?,'custom' WHERE EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard}) ON CONFLICT(hostname) DO UPDATE SET active=excluded.active,verified=1,kind='custom' WHERE platform_domains.site_id=excluded.site_id`,
host,
row.site_id,
active ? 1 : 0,
...args,
),
stmt(
`UPDATE platform_custom_domains SET revision=revision+1,state=?,is_primary=CASE WHEN ?=1 THEN CASE WHEN restore_primary=1 AND NOT EXISTS(SELECT 1 FROM platform_custom_domains other WHERE other.site_id=platform_custom_domains.site_id AND other.hostname<>platform_custom_domains.hostname AND other.is_primary=1) THEN 1 ELSE is_primary END ELSE 0 END,hold_reason=NULL,error=?,attempts=CASE WHEN state='active' THEN 0 ELSE attempts+1 END,checked_at=?,verified_at=CASE WHEN ?=1 THEN ? ELSE verified_at END,next_check_at=?,lease_token=NULL,lease_until=NULL WHERE ${guard}`,
active ? 'active' : 'pending',
active ? 1 : 0,
config.routingReady ? null : 'domain_routing_unavailable',
time,
active ? 1 : 0,
time,
time +
(active
? 1800000
: Math.min(1800000, 60000 * 2 ** Math.min(row.attempts, 5))),
...args,
),
],
active !== (row.state === 'active')
? active
? 'activated'
: 'pending'
: undefined,
)
checked++
} catch (error) {
const code =
error instanceof DomainError
? error.code
: 'domain_provider_unavailable'
const terminal =
code === 'domain_provider_conflict' ||
code === 'domain_provider_missing'
await db.batch([
stmt(
`UPDATE platform_domains SET active=0 WHERE hostname=? AND EXISTS(SELECT 1 FROM platform_custom_domains WHERE ${guard} AND (?=1 OR verified_at IS NULL OR verified_at<?))`,
host,
...args,
terminal ? 1 : 0,
time - DOMAIN_HEALTH_TTL,
),
stmt(
`UPDATE platform_custom_domains SET revision=revision+1,state=CASE WHEN state IN ('deleting','expired','paused') THEN state WHEN ?=1 OR verified_at IS NULL OR verified_at<? THEN 'pending' ELSE state END,is_primary=CASE WHEN ?=1 OR verified_at IS NULL OR verified_at<? THEN 0 ELSE is_primary END,error=?,attempts=attempts+1,checked_at=?,next_check_at=?,lease_token=NULL,lease_until=NULL WHERE ${guard}`,
terminal ? 1 : 0,
time - DOMAIN_HEALTH_TTL,
terminal ? 1 : 0,
time - DOMAIN_HEALTH_TTL,
code,
time,
time + Math.min(1800000, 30000 * 2 ** Math.min(row.attempts, 6)),
...args,
),
])
}
}
return { checked }
}
async function defaultPrimary(userId: number, siteId: number) {
const site = await authorize(userId, siteId)
await db.batch([
stmt(
`UPDATE platform_custom_domains SET is_primary=0,restore_primary=0,redirects=0,revision=revision+1 WHERE site_id=? AND ${memberGuard}`,
siteId,
siteId,
userId,
),
stmt(
`INSERT INTO platform_domain_audit(site_id,hostname,generation,action,user_id,created_at) SELECT ?,?,?,'default-primary',?,? WHERE ${memberGuard}`,
siteId,
validSiteSlug(site.slug) ? defaultSiteHost(site.slug, base) : base,
'default-' + site.revision,
userId,
now(),
siteId,
userId,
),
])
return { ok: true }
}
return { list, request, mutate, reconcile, authorize, defaultPrimary }
}
/** Atomically reserve a new default address and keep the previous address as a temporary alias. */
export async function renameDefaultDomain(
db: PlatformD1,
userId: number,
siteId: number,
input: { slug: unknown; revision: unknown },
base = DEFAULT_SITE_BASE,
now = Date.now(),
) {
if (!validSiteSlug(input.slug) || !Number.isSafeInteger(input.revision))
throw new DomainError(400, 'domain_invalid')
const current = await db
.prepare(
`SELECT s.slug,s.revision FROM platform_sites s JOIN platform_memberships m ON m.workspace_id=s.workspace_id WHERE s.id=? AND s.suspended=0 AND m.user_id=? AND m.role='admin'`,
)
.bind(siteId, userId)
.first<{ slug: string; revision: number }>()
if (!current) throw new DomainError(403, 'domain_admin_required')
if (current.revision !== input.revision)
throw new DomainError(409, 'domain_changed')
if (current.slug === input.slug) return { ok: true }
const host = defaultSiteHost(input.slug, base),
guard =
"EXISTS(SELECT 1 FROM platform_sites s JOIN platform_memberships m ON m.workspace_id=s.workspace_id WHERE s.id=? AND s.suspended=0 AND s.revision=? AND m.user_id=? AND m.role='admin')",
args = [siteId, current.revision, userId]
try {
const results = await db.batch([
db
.prepare(
`INSERT INTO platform_site_slugs(slug,site_id) SELECT ?,? WHERE ${guard} ON CONFLICT(slug) DO UPDATE SET site_id=CASE WHEN platform_site_slugs.site_id=excluded.site_id THEN platform_site_slugs.site_id ELSE NULL END`,
)
.bind(input.slug, siteId, ...args),
db
.prepare(
`INSERT INTO platform_domains(hostname,site_id,verified,active,kind) SELECT ?,?,1,1,'default' WHERE ${guard} ON CONFLICT(hostname) DO UPDATE SET site_id=CASE WHEN platform_domains.site_id=excluded.site_id THEN platform_domains.site_id ELSE NULL END,active=1,redirect_to=NULL,redirect_until=NULL,kind='default'`,
)
.bind(host, siteId, ...args),
db
.prepare(
`UPDATE platform_domains SET kind='alias',redirect_to=?,redirect_until=? WHERE site_id=? AND hostname<>? AND kind IN ('default','legacy','alias') AND ${guard}`,
)
.bind(host, now + 7 * 86400000, siteId, host, ...args),
db
.prepare(
`INSERT INTO platform_domain_audit(site_id,hostname,generation,action,user_id,created_at) SELECT ?,?,?,'rename',?,? WHERE ${guard}`,
)
.bind(
siteId,
host,
'default-' + current.revision,
userId,
now,
...args,
),
db
.prepare(
`UPDATE platform_sites SET slug=?,revision=revision+1 WHERE id=? AND revision=? AND platform_sites.suspended=0 AND EXISTS(SELECT 1 FROM platform_memberships WHERE workspace_id=platform_sites.workspace_id AND user_id=? AND role='admin')`,
)
.bind(input.slug, ...args),
])
if (results[4]?.meta.changes !== 1)
throw new DomainError(409, 'domain_changed')
return { ok: true }
} catch (error) {
if (/UNIQUE constraint|NOT NULL constraint/.test(String(error)))
throw new DomainError(409, 'domain_conflict')
throw error
}
}