chore(格式): Prettier 统一到全仓，后端和契约一次性格式化

原来只有 `apps/web` 在 Prettier 下（配置在 `apps/web/.prettierrc.toml`、脚本在
web 的 package.json），后端和契约从来没格式化过 —— 手写在 100 列上下，`db/schema.ts`
还是 drizzle-kit pull 留下的 tab 缩进。两套口径分叉久了，跨端改一处就得记着「这边
什么风格」。

- 配置搬到根目录 `.prettierrc.toml`，内容不变（`semi=false`，其余全默认，
  printWidth 80 —— 和前端已有的格式一致，不另立一套宽度）；
- 脚本统一成根目录 `bun run fmt`，覆盖 `apps/*/src`、`apps/web/tests` 和两个构建
  配置；web 自己那份 `fmt` 和重复的 prettier 依赖删掉；
- `.prettierignore` 挡掉两类不该碰的：drizzle-kit 生成的 `src/db/meta/` 结构快照
  （它是 db:generate 的比对输入，只该由 drizzle-kit 写）、unplugin 每次 dev 都会
  重写的 `auto-imports.d.ts` / `components.d.ts`；
- 全量跑了一遍。纯格式，无行为改动：api typecheck / check:routes / check:ast、
  前端 type-check 全过，起 api 打了接口确认正常。前端这 39 个文件的小改动是
  prettier 版本漂移（类型断言的换行口径变了），不是新配置带来的。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

apps/api/src/routes/account.ts

@@ -42,15 +42,28 @@ import { failure, success } from "../http"
 import { JudgeStatus } from "../judge/status"
 import { getBooleanOption } from "../services/options"
 import { getUserProfileById } from "../services/profile"
-import { isTeacherOrAbove, objectValue, queryInteger, sampleUser } from "./helpers"
+import {
+  isTeacherOrAbove,
+  objectValue,
+  queryInteger,
+  sampleUser,
+} from "./helpers"
 
 export const accountRoutes = new Hono<AppEnv>()
 
 accountRoutes.post("/users", async (c) => {
-  const parsed = registerRequestSchema.safeParse(await c.req.json().catch(() => null))
-  if (!parsed.success) return failure(c, 400, "invalid-request", "Invalid registration payload")
+  const parsed = registerRequestSchema.safeParse(
+    await c.req.json().catch(() => null),
+  )
+  if (!parsed.success)
+    return failure(c, 400, "invalid-request", "Invalid registration payload")
   if (!(await getBooleanOption("allow_register", true))) {
-    return failure(c, 403, "registration-disabled", "Register function has been disabled by admin")
+    return failure(
+      c,
+      403,
+      "registration-disabled",
+      "Register function has been disabled by admin",
+    )
   }
 
   const username = parsed.data.username.toLowerCase()
@@ -58,7 +71,12 @@ accountRoutes.post("/users", async (c) => {
   const [duplicate] = await db
     .select({ username: schema.user.username, email: schema.user.email })
     .from(schema.user)
-    .where(or(sql`lower(${schema.user.username}) = ${username}`, sql`lower(${schema.user.email}) = ${email}`))
+    .where(
+      or(
+        sql`lower(${schema.user.username}) = ${username}`,
+        sql`lower(${schema.user.email}) = ${email}`,
+      ),
+    )
     .limit(1)
   if (duplicate?.username.toLowerCase() === username) {
     return failure(c, 409, "username-exists", "Username already exists")
@@ -70,18 +88,21 @@ accountRoutes.post("/users", async (c) => {
   const now = new Date().toISOString()
   const password = await hashPassword(parsed.data.password)
   await db.transaction(async (tx) => {
-    const [created] = await tx.insert(schema.user).values({
-      username,
-      email,
-      password,
-      rawPassword: parsed.data.password.slice(0, 20),
-      lastLogin: null,
-      createTime: now,
-      adminType: "Regular User",
-      isDisabled: false,
-      problemPermission: "None",
-      className: null,
-    }).returning({ id: schema.user.id })
+    const [created] = await tx
+      .insert(schema.user)
+      .values({
+        username,
+        email,
+        password,
+        rawPassword: parsed.data.password.slice(0, 20),
+        lastLogin: null,
+        createTime: now,
+        adminType: "Regular User",
+        isDisabled: false,
+        problemPermission: "None",
+        className: null,
+      })
+      .returning({ id: schema.user.id })
     if (!created) throw new Error("User insert did not return an id")
     await tx.insert(schema.userProfile).values({
       userId: created.id,
@@ -101,31 +122,57 @@ accountRoutes.get("/profiles/:username", optionalAuth, async (c) => {
   // `if not user.is_authenticated: return self.success()` —— 匿名一律返回空，
   // 否则用户名可经 /rankings/users 公开枚举，进而无 cookie 批量收集全校学生的邮箱与最后登录时间。
   if (!c.get("user")) return success(c, null)
-  const [target] = await db.select({ id: schema.user.id }).from(schema.user)
-    .where(and(sql`lower(${schema.user.username}) = lower(${c.req.param("username")})`, eq(schema.user.isDisabled, false))).limit(1)
+  const [target] = await db
+    .select({ id: schema.user.id })
+    .from(schema.user)
+    .where(
+      and(
+        sql`lower(${schema.user.username}) = lower(${c.req.param("username")})`,
+        eq(schema.user.isDisabled, false),
+      ),
+    )
+    .limit(1)
   if (!target) return failure(c, 404, "user-not-found", "User does not exist")
-  const profile = await getUserProfileById(target.id, c.get("user")?.id === target.id)
-  if (!profile) return failure(c, 404, "profile-not-found", "User profile does not exist")
+  const profile = await getUserProfileById(
+    target.id,
+    c.get("user")?.id === target.id,
+  )
+  if (!profile)
+    return failure(c, 404, "profile-not-found", "User profile does not exist")
   return success(c, profile)
 })
 
 accountRoutes.put("/me/profile", requireAuth, async (c) => {
-  const parsed = updateProfileRequestSchema.safeParse(await c.req.json().catch(() => null))
-  if (!parsed.success) return failure(c, 400, "invalid-request", "Invalid profile payload")
-  const values = Object.fromEntries(
-    Object.entries(parsed.data).map(([key, value]) => [key, value === "" ? null : value]),
+  const parsed = updateProfileRequestSchema.safeParse(
+    await c.req.json().catch(() => null),
   )
-  await db.update(schema.userProfile).set(values).where(eq(schema.userProfile.userId, c.get("user")!.id))
+  if (!parsed.success)
+    return failure(c, 400, "invalid-request", "Invalid profile payload")
+  const values = Object.fromEntries(
+    Object.entries(parsed.data).map(([key, value]) => [
+      key,
+      value === "" ? null : value,
+    ]),
+  )
+  await db
+    .update(schema.userProfile)
+    .set(values)
+    .where(eq(schema.userProfile.userId, c.get("user")!.id))
   const profile = await getUserProfileById(c.get("user")!.id, true)
-  if (!profile) return failure(c, 404, "profile-not-found", "User profile does not exist")
+  if (!profile)
+    return failure(c, 404, "profile-not-found", "User profile does not exist")
   return success(c, profile)
 })
 
 accountRoutes.post("/me/avatar", requireAuth, async (c) => {
-  const body: Record<string, string | File> = await c.req.parseBody().catch(() => ({}))
+  const body: Record<string, string | File> = await c.req
+    .parseBody()
+    .catch(() => ({}))
   const image = body.image
-  if (!(image instanceof File)) return failure(c, 400, "invalid-file", "Invalid file content")
-  if (image.size > 2 * 1024 * 1024) return failure(c, 400, "file-too-large", "Picture is too large")
+  if (!(image instanceof File))
+    return failure(c, 400, "invalid-file", "Invalid file content")
+  if (image.size > 2 * 1024 * 1024)
+    return failure(c, 400, "file-too-large", "Picture is too large")
   const extension = extname(image.name).toLowerCase()
   if (![".gif", ".jpg", ".jpeg", ".bmp", ".png"].includes(extension)) {
     return failure(c, 400, "unsupported-file", "Unsupported file format")
@@ -135,17 +182,35 @@ accountRoutes.post("/me/avatar", requireAuth, async (c) => {
   await Bun.$`mkdir -p ${directory}`.quiet()
   await Bun.write(resolve(directory, filename), image)
   const avatar = `${config.avatarUriPrefix}/${filename}`
-  await db.update(schema.userProfile).set({ avatar }).where(eq(schema.userProfile.userId, c.get("user")!.id))
+  await db
+    .update(schema.userProfile)
+    .set({ avatar })
+    .where(eq(schema.userProfile.userId, c.get("user")!.id))
   return success(c, { avatar })
 })
 
 accountRoutes.get("/users/:id/metrics", async (c) => {
   const userId = queryInteger(c.req.param("id"), 0, { min: 1 })
-  const [row] = await db.select({ total: count(), first: min(schema.submission.createTime), latest: sql<string>`max(${schema.submission.createTime})` })
+  const [row] = await db
+    .select({
+      total: count(),
+      first: min(schema.submission.createTime),
+      latest: sql<string>`max(${schema.submission.createTime})`,
+    })
     .from(schema.submission)
-    .where(and(eq(schema.submission.userId, userId), isNull(schema.submission.contestId)))
-  if (!row?.total || !row.first || !row.latest) return failure(c, 404, "no-submissions", "暂无提交")
-  return success(c, { now: new Date().toISOString(), first: row.first, latest: row.latest } satisfies Metrics)
+    .where(
+      and(
+        eq(schema.submission.userId, userId),
+        isNull(schema.submission.contestId),
+      ),
+    )
+  if (!row?.total || !row.first || !row.latest)
+    return failure(c, 404, "no-submissions", "暂无提交")
+  return success(c, {
+    now: new Date().toISOString(),
+    first: row.first,
+    latest: row.latest,
+  } satisfies Metrics)
 })
 
 /**
@@ -178,7 +243,10 @@ const leaderboardOrder = [
 ]
 
 accountRoutes.get("/rankings/users", optionalAuth, async (c) => {
-  const limit = queryInteger(c.req.query("limit"), 10, { min: 1, max: LEADERBOARD_SIZE })
+  const limit = queryInteger(c.req.query("limit"), 10, {
+    min: 1,
+    max: LEADERBOARD_SIZE,
+  })
   const offset = queryInteger(c.req.query("offset"), 0, { min: 0 })
 
   // 榜单封顶 100 名，所以这一页最多还能取几条只取决于 offset，**不取决于总人数** ——
@@ -188,14 +256,22 @@ accountRoutes.get("/rankings/users", optionalAuth, async (c) => {
 
   // 谁在线只给老师看，学生那边整列都是 null（见 rankProfileSchema.isOnline）
   const [totalRow, rows, me, online] = await Promise.all([
-    db.select({ value: count() }).from(schema.userProfile)
+    db
+      .select({ value: count() })
+      .from(schema.userProfile)
       .innerJoin(schema.user, eq(schema.userProfile.userId, schema.user.id))
-      .where(leaderboardWhere).then(([row]) => row),
-    pageLimit === 0 ? [] : db
-      .select({ profile: schema.userProfile, user: schema.user }).from(schema.userProfile)
-      .innerJoin(schema.user, eq(schema.userProfile.userId, schema.user.id))
-      .where(leaderboardWhere).orderBy(...leaderboardOrder)
-      .limit(pageLimit).offset(offset),
+      .where(leaderboardWhere)
+      .then(([row]) => row),
+    pageLimit === 0
+      ? []
+      : db
+          .select({ profile: schema.userProfile, user: schema.user })
+          .from(schema.userProfile)
+          .innerJoin(schema.user, eq(schema.userProfile.userId, schema.user.id))
+          .where(leaderboardWhere)
+          .orderBy(...leaderboardOrder)
+          .limit(pageLimit)
+          .offset(offset),
     myLeaderboardRank(c.get("user")?.id),
     isTeacherOrAbove(c.get("user")) ? onlineUserIds() : null,
   ])
@@ -207,10 +283,16 @@ accountRoutes.get("/rankings/users", optionalAuth, async (c) => {
   } satisfies UserRank)
 })
 
-function serializeRankRow({ profile, user }: {
-  profile: typeof schema.userProfile.$inferSelect
-  user: typeof schema.user.$inferSelect
-}, online: Set<number> | null = null) {
+function serializeRankRow(
+  {
+    profile,
+    user,
+  }: {
+    profile: typeof schema.userProfile.$inferSelect
+    user: typeof schema.user.$inferSelect
+  },
+  online: Set<number> | null = null,
+) {
   return {
     id: profile.id,
     user: sampleUser(user, profile.realName),
@@ -231,26 +313,35 @@ function serializeRankRow({ profile, user }: {
 async function myLeaderboardRank(userId: number | undefined) {
   if (!userId) return null
   const [mine] = await db
-    .select({ profile: schema.userProfile, user: schema.user }).from(schema.userProfile)
+    .select({ profile: schema.userProfile, user: schema.user })
+    .from(schema.userProfile)
     .innerJoin(schema.user, eq(schema.userProfile.userId, schema.user.id))
-    .where(and(leaderboardWhere, eq(schema.user.id, userId))).limit(1)
+    .where(and(leaderboardWhere, eq(schema.user.id, userId)))
+    .limit(1)
   if (!mine) return null
 
   const { acceptedNumber, submissionNumber } = mine.profile
-  const [ahead] = await db.select({ value: count() }).from(schema.userProfile)
+  const [ahead] = await db
+    .select({ value: count() })
+    .from(schema.userProfile)
     .innerJoin(schema.user, eq(schema.userProfile.userId, schema.user.id))
-    .where(and(leaderboardWhere, or(
-      gt(schema.userProfile.acceptedNumber, acceptedNumber),
+    .where(
       and(
-        eq(schema.userProfile.acceptedNumber, acceptedNumber),
-        lt(schema.userProfile.submissionNumber, submissionNumber),
+        leaderboardWhere,
+        or(
+          gt(schema.userProfile.acceptedNumber, acceptedNumber),
+          and(
+            eq(schema.userProfile.acceptedNumber, acceptedNumber),
+            lt(schema.userProfile.submissionNumber, submissionNumber),
+          ),
+          and(
+            eq(schema.userProfile.acceptedNumber, acceptedNumber),
+            eq(schema.userProfile.submissionNumber, submissionNumber),
+            lt(schema.user.id, userId),
+          ),
+        ),
       ),
-      and(
-        eq(schema.userProfile.acceptedNumber, acceptedNumber),
-        eq(schema.userProfile.submissionNumber, submissionNumber),
-        lt(schema.user.id, userId),
-      ),
-    )))
+    )
 
   return {
     ...serializeRankRow(mine),
@@ -260,7 +351,8 @@ async function myLeaderboardRank(userId: number | undefined) {
 
 accountRoutes.get("/rankings/activity", async (c) => {
   const start = c.req.query("start")
-  if (!start || Number.isNaN(Date.parse(start))) return failure(c, 400, "invalid-start", "start time is required")
+  if (!start || Number.isNaN(Date.parse(start)))
+    return failure(c, 400, "invalid-start", "start time is required")
   /**
    * 按 **user_id** 聚合，名字从 user 表取。按 `submission.username` 分组的话，
    * 改过名的学生会裂成新旧两条各算各的 AC 题数 —— 排名被拆低，运气不好还会以
@@ -268,43 +360,105 @@ accountRoutes.get("/rankings/activity", async (c) => {
    *
    * innerJoin user 顺带把已删号学生的孤儿提交挡在外面，不用再兜底名字。
    */
-  const rows = await db.select({ username: schema.user.username, value: countDistinct(schema.submission.problemId) })
+  const rows = await db
+    .select({
+      username: schema.user.username,
+      value: countDistinct(schema.submission.problemId),
+    })
     .from(schema.submission)
     .innerJoin(schema.user, eq(schema.submission.userId, schema.user.id))
-    .where(and(
-      isNull(schema.submission.contestId),
-      gte(schema.submission.createTime, start),
-      inArray(schema.submission.result, [JudgeStatus.ACCEPTED, JudgeStatus.AST_CHECK_FAILED]),
-      eq(schema.user.isDisabled, false),
-      ne(schema.user.adminType, "Super Admin"),
-    ))
+    .where(
+      and(
+        isNull(schema.submission.contestId),
+        gte(schema.submission.createTime, start),
+        inArray(schema.submission.result, [
+          JudgeStatus.ACCEPTED,
+          JudgeStatus.AST_CHECK_FAILED,
+        ]),
+        eq(schema.user.isDisabled, false),
+        ne(schema.user.adminType, "Super Admin"),
+      ),
+    )
     .groupBy(schema.submission.userId, schema.user.username)
-    .orderBy(desc(countDistinct(schema.submission.problemId))).limit(10)
-  return success(c, rows.map((row) => ({ username: row.username, count: row.value } satisfies ActivityRankItem)))
+    .orderBy(desc(countDistinct(schema.submission.problemId)))
+    .limit(10)
+  return success(
+    c,
+    rows.map(
+      (row) =>
+        ({
+          username: row.username,
+          count: row.value,
+        }) satisfies ActivityRankItem,
+    ),
+  )
 })
 
 accountRoutes.get("/problems/:displayId/rank", requireAuth, async (c) => {
   const user = c.get("user")!
-  const [problem] = await db.select({ id: schema.problem.id }).from(schema.problem)
-    .where(and(sql`lower(${schema.problem.displayId}) = lower(${c.req.param("displayId")})`, isNull(schema.problem.contestId), eq(schema.problem.visible, true))).limit(1)
-  if (!problem) return failure(c, 404, "problem-not-found", "Problem does not exist")
-  const accepted = and(eq(schema.submission.problemId, problem.id), inArray(schema.submission.result, [0, 10]))
-  const [all] = await db.select({ value: countDistinct(schema.submission.userId) }).from(schema.submission).where(accepted)
+  const [problem] = await db
+    .select({ id: schema.problem.id })
+    .from(schema.problem)
+    .where(
+      and(
+        sql`lower(${schema.problem.displayId}) = lower(${c.req.param("displayId")})`,
+        isNull(schema.problem.contestId),
+        eq(schema.problem.visible, true),
+      ),
+    )
+    .limit(1)
+  if (!problem)
+    return failure(c, 404, "problem-not-found", "Problem does not exist")
+  const accepted = and(
+    eq(schema.submission.problemId, problem.id),
+    inArray(schema.submission.result, [0, 10]),
+  )
+  const [all] = await db
+    .select({ value: countDistinct(schema.submission.userId) })
+    .from(schema.submission)
+    .where(accepted)
   const className = user.className ?? ""
   const classWhere = className
-    ? and(accepted, inArray(schema.submission.userId, db.select({ id: schema.user.id }).from(schema.user).where(and(eq(schema.user.className, className), eq(schema.user.isDisabled, false)))))
+    ? and(
+        accepted,
+        inArray(
+          schema.submission.userId,
+          db
+            .select({ id: schema.user.id })
+            .from(schema.user)
+            .where(
+              and(
+                eq(schema.user.className, className),
+                eq(schema.user.isDisabled, false),
+              ),
+            ),
+        ),
+      )
     : accepted
   const [classCount] = className
-    ? await db.select({ value: countDistinct(schema.submission.userId) }).from(schema.submission).where(classWhere)
+    ? await db
+        .select({ value: countDistinct(schema.submission.userId) })
+        .from(schema.submission)
+        .where(classWhere)
     : [{ value: 0 }]
-  const [first] = await db.select({ value: min(schema.submission.createTime) }).from(schema.submission)
+  const [first] = await db
+    .select({ value: min(schema.submission.createTime) })
+    .from(schema.submission)
     .where(and(classWhere, eq(schema.submission.userId, user.id)))
   let rank = -1
   if (first?.value) {
-    const [rankRow] = await db.select({ value: count() }).from(schema.submission).where(and(classWhere, lte(schema.submission.createTime, first.value)))
+    const [rankRow] = await db
+      .select({ value: count() })
+      .from(schema.submission)
+      .where(and(classWhere, lte(schema.submission.createTime, first.value)))
     rank = rankRow?.value ?? -1
   }
-  return success(c, { className, rank, classAcCount: classCount?.value ?? 0, allAcCount: all?.value ?? 0 } satisfies ProblemRank)
+  return success(c, {
+    className,
+    rank,
+    classAcCount: classCount?.value ?? 0,
+    allAcCount: all?.value ?? 0,
+  } satisfies ProblemRank)
 })
 
 /**
@@ -319,25 +473,44 @@ accountRoutes.get("/problems/:displayId/rank", requireAuth, async (c) => {
  * 题目一旦被隐藏或删除，display_ids 就比 ids 短 —— 轻则把编号张冠李戴写进库，
  * 重则 `id_map[k]` KeyError。这里改成按 id 建 Map、查不到就不动。
  */
-accountRoutes.post("/me/problem-display-ids/refresh", requireAuth, async (c) => {
-  const user = c.get("user")!
-  const [profile] = await db.select({ value: schema.userProfile.acmProblemsStatus }).from(schema.userProfile)
-    .where(eq(schema.userProfile.userId, user.id)).limit(1)
-  const status = objectValue(profile?.value)
-  const problems = objectValue(status.problems)
-  const ids = Object.keys(problems).map(Number).filter(Number.isInteger)
-  if (ids.length > 0) {
-    const rows = await db.select({ id: schema.problem.id, displayId: schema.problem.displayId }).from(schema.problem)
-      .where(and(inArray(schema.problem.id, ids), eq(schema.problem.visible, true)))
-    const displayIds = new Map(rows.map((row) => [String(row.id), row.displayId]))
-    for (const [id, value] of Object.entries(problems)) {
-      const item = objectValue(value)
-      const displayId = displayIds.get(id)
-      if (displayId) item._id = displayId
-      problems[id] = item
+accountRoutes.post(
+  "/me/problem-display-ids/refresh",
+  requireAuth,
+  async (c) => {
+    const user = c.get("user")!
+    const [profile] = await db
+      .select({ value: schema.userProfile.acmProblemsStatus })
+      .from(schema.userProfile)
+      .where(eq(schema.userProfile.userId, user.id))
+      .limit(1)
+    const status = objectValue(profile?.value)
+    const problems = objectValue(status.problems)
+    const ids = Object.keys(problems).map(Number).filter(Number.isInteger)
+    if (ids.length > 0) {
+      const rows = await db
+        .select({ id: schema.problem.id, displayId: schema.problem.displayId })
+        .from(schema.problem)
+        .where(
+          and(
+            inArray(schema.problem.id, ids),
+            eq(schema.problem.visible, true),
+          ),
+        )
+      const displayIds = new Map(
+        rows.map((row) => [String(row.id), row.displayId]),
+      )
+      for (const [id, value] of Object.entries(problems)) {
+        const item = objectValue(value)
+        const displayId = displayIds.get(id)
+        if (displayId) item._id = displayId
+        problems[id] = item
+      }
+      status.problems = problems
+      await db
+        .update(schema.userProfile)
+        .set({ acmProblemsStatus: status })
+        .where(eq(schema.userProfile.userId, user.id))
     }
-    status.problems = problems
-    await db.update(schema.userProfile).set({ acmProblemsStatus: status }).where(eq(schema.userProfile.userId, user.id))
-  }
-  return success(c, null)
-})
+    return success(c, null)
+  },
+)