AI-native design editor. Open-source Figma alternative.
import { requireTrustedMutationOrigin } from '#cloud/admin/api/security'
import type { AdminAuditService } from '#cloud/admin/audit/service'
import type { AdminEmailService } from '#cloud/admin/email/service'
import type { EnrollmentService } from '#cloud/admin/enrollment/service'
import { adminErrorStatus, AdminDomainError } from '#cloud/admin/errors'
import type { AdminOperationsService } from '#cloud/admin/operations/service'
import {
enrollmentStatusSchema,
parseEnrollmentReview,
parseUserMutation,
parseUserRoleMutation
} from '#cloud/admin/schema'
import type { AdminUserService } from '#cloud/admin/users/service'
import {
cloudAdminAuditFilterSchema,
cloudAdminEmailFilterSchema,
cloudAdminUserFilterSchema
} from '#cloud/contract'
import type { CloudAPIEnvironment } from '#cloud/server/api'
import type { CloudAuthAdapter } from '#cloud/server/auth'
import type { CloudDatabase } from '#cloud/server/db'
import { CLOUD_RATE_LIMITS, createActorRateLimiter } from '#cloud/server/rate-limit'
import { idParams, validatedJSON, validatedQuery } from '#cloud/server/validation'
import { Hono, type Context } from 'hono'
import { NoResultError, type Kysely } from 'kysely'
import * as v from 'valibot'
/**
* A count from the query string; anything but digits, or a number too large to be exact, is a bad
* request rather than a NaN or out-of-range query.
*/
const countSchema = v.optional(v.pipe(v.string(), v.digits(), v.toNumber(), v.safeInteger()))
/** What an admin list reads from its query string: a search, one of `filters`, and a page. */
function listQuery<const Filter extends string>(filters: v.PicklistSchema<Filter[], undefined>) {
const schema = v.object({
search: v.optional(v.string()),
filter: v.optional(filters),
limit: countSchema,
offset: countSchema
})
return (input: unknown) => v.parse(schema, input)
}
const parseEnrollmentQuery = listQuery(enrollmentStatusSchema)
const parseUserQuery = listQuery(cloudAdminUserFilterSchema)
const parseEmailQuery = listQuery(cloudAdminEmailFilterSchema)
const parseAuditQuery = listQuery(cloudAdminAuditFilterSchema)
/** Accounts are named by UUID; anything else names no one, rather than failing the query. */
const accountIdSchema = v.pipe(v.string(), v.uuid())
/** Does what an administrator asked to another account; one that is not an account is not found. */
async function accountMutation(
context: Context<CloudAPIEnvironment>,
userId: string,
mutate: (actorId: string, userId: string) => Promise<void>
) {
if (!v.is(accountIdSchema, userId)) {
return context.json({ error: { code: 'not_found' as const } }, 404)
}
await mutate(context.get('actor').userId, userId)
return context.json({ ok: true as const })
}
export type CloudAdminServices = {
email: AdminEmailService
enrollment: EnrollmentService
users: AdminUserService
audit: AdminAuditService
operations: AdminOperationsService
}
export function createCloudAdminRoutes(
services: CloudAdminServices,
trustedOrigins: ReadonlySet<string>,
security: {
auth: CloudAuthAdapter
database: Kysely<CloudDatabase>
requireMFA: boolean
secret: string
}
) {
const adminRead = createActorRateLimiter(
security.database,
security.secret,
CLOUD_RATE_LIMITS.adminRead,
(context) => context.req.method !== 'GET'
)
const adminMutation = createActorRateLimiter(
security.database,
security.secret,
CLOUD_RATE_LIMITS.adminMutation,
(context) => context.req.method === 'GET'
)
return new Hono<CloudAPIEnvironment>()
.use('*', requireTrustedMutationOrigin(trustedOrigins))
.use('*', async (context, next) => {
const actor = context.get('actor')
if (actor.deploymentRole !== 'admin') {
return context.json({ error: { code: 'forbidden' as const } }, 403)
}
if (security.requireMFA) {
const status = await security.auth.mfaStatus(context.req.raw.headers)
if (!status?.assured) {
return context.json({ error: { code: 'mfa_required' as const } }, 403)
}
}
return next()
})
.use('*', adminRead)
.use('*', adminMutation)
.onError((error, context) => {
if (error instanceof AdminDomainError) {
return context.json({ error: { code: error.code } }, adminErrorStatus(error))
}
if (error instanceof v.ValiError) {
return context.json({ error: { code: 'invalid_request' as const } }, 400)
}
// An enrollment or message ID that names nothing.
if (error instanceof NoResultError) {
return context.json({ error: { code: 'not_found' as const } }, 404)
}
throw error
})
.get('/enrollments', validatedQuery(parseEnrollmentQuery), async (context) =>
context.json(await services.enrollment.list(context.req.valid('query')))
)
.post(
'/enrollments/:id/approve',
idParams,
validatedJSON(parseEnrollmentReview),
async (context) =>
context.json({
enrollment: await services.enrollment.review(
context.get('actor').userId,
context.req.valid('param').id,
'approved',
context.req.valid('json')
)
})
)
.post(
'/enrollments/:id/reject',
idParams,
validatedJSON(parseEnrollmentReview),
async (context) =>
context.json({
enrollment: await services.enrollment.review(
context.get('actor').userId,
context.req.valid('param').id,
'rejected',
context.req.valid('json')
)
})
)
.post(
'/enrollments/:id/revoke',
idParams,
validatedJSON(parseEnrollmentReview),
async (context) =>
context.json({
enrollment: await services.enrollment.review(
context.get('actor').userId,
context.req.valid('param').id,
'revoked',
context.req.valid('json')
)
})
)
.get('/users', validatedQuery(parseUserQuery), async (context) =>
context.json(await services.users.list(context.req.valid('query')))
)
.get('/users/:id', idParams, async (context) => {
const detail = await services.users.detail(context.req.valid('param').id)
if (!detail) return context.json({ error: { code: 'not_found' as const } }, 404)
return context.json(detail)
})
.post('/users/reset-two-step', validatedJSON(parseUserMutation), (context) =>
accountMutation(context, context.req.valid('json').userId, (actorId, userId) =>
services.users.resetTwoStep(actorId, userId)
)
)
.post('/users/remove-picture', validatedJSON(parseUserMutation), (context) =>
accountMutation(context, context.req.valid('json').userId, (actorId, userId) =>
services.users.removePicture(actorId, userId)
)
)
.post('/users/ban', validatedJSON(parseUserMutation), async (context) => {
const input = context.req.valid('json')
await services.users.ban(
context.req.raw.headers,
context.get('actor').userId,
input.userId,
input.reason
)
return context.json({ ok: true as const })
})
.post('/users/unban', validatedJSON(parseUserMutation), async (context) => {
const input = context.req.valid('json')
await services.users.unban(context.req.raw.headers, context.get('actor').userId, input.userId)
return context.json({ ok: true as const })
})
.post('/users/revoke-sessions', validatedJSON(parseUserMutation), async (context) => {
const input = context.req.valid('json')
await services.users.revokeSessions(
context.req.raw.headers,
context.get('actor').userId,
input.userId
)
return context.json({ ok: true as const })
})
.post('/users/set-admin', validatedJSON(parseUserRoleMutation), async (context) => {
const input = context.req.valid('json')
await services.users.setAdmin(
context.req.raw.headers,
context.get('actor').userId,
input.userId,
input.enabled
)
return context.json({ ok: true as const })
})
.get('/email', validatedQuery(parseEmailQuery), async (context) =>
context.json(await services.email.list(context.req.valid('query')))
)
.post('/email/:id/regenerate', idParams, async (context) => {
await services.email.regenerate(context.get('actor').userId, context.req.valid('param').id)
return context.json({ ok: true as const })
})
.get('/audit', validatedQuery(parseAuditQuery), async (context) =>
context.json(await services.audit.list(context.req.valid('query')))
)
.get('/operations', async (context) => context.json(await services.operations.summary()))
}
/** The administration routes' types, for the portal's typed client. */
export type CloudAdminRoutes = ReturnType<typeof createCloudAdminRoutes>