node-resource-utils 0.0.0-stage → 1.1.7

package/resources/src/app/api/ai/report/route.ts

@@ -0,0 +1,164 @@
+import { ok, withRoute, audit, BizError, CODE } from '@/lib/api';
+import { currentUser } from '@/auth';
+import { prisma } from '@/lib/prisma';
+import { aiChat, cleanAiText } from '@/lib/ai';
+
+/**
+ * 「数据 → 报告」生成器 —— 这是整套骨架里最有差异化的一块。
+ *
+ * 别的队伍在用大模型写代码，你把**大模型用进了产品里**。
+ * 评委打开系统看到一个「一键生成报告」，印象分直接拉开差距。
+ *
+ * 用法（模型接业务时只要调这一个接口）:
+ *   POST /api/ai/report
+ *   {
+ *     "table": "dutyLog",          // Prisma 模型名（会校验是否真实存在）
+ *     "title": "值班周报",
+ *     "dateField": "createdAt",    // 用哪个字段做时间过滤（可选）
+ *     "from": "2026-10-06",
+ *     "to":   "2026-10-12",
+ *     "focus": "突出处理了什么问题、值班强度、需要注意的风险",  // 可选
+ *     "limit": 200
+ *   }
+ *
+ * 返回: { report, rows, title, model, generatedAt }
+ */
+
+/** 不让调用方碰账号/权限这类敏感表 */
+const BLOCKED_MODELS = new Set(['User', 'Role', 'Menu', 'UserRole', 'RoleMenu']);
+
+/** Prisma delegate —— 只用到 findMany */
+type Delegate = { findMany: (args: unknown) => Promise<Record<string, unknown>[]> };
+
+/**
+ * 取某个模型的字段名集合。
+ *
+ * 为什么要自己取：`deletedAt` 只存在于有软删的表上，
+ * 无条件往 where 里塞 `deletedAt: null`，OperationLog / Department 这类表
+ * 会直接抛 `Unknown argument`。字段集从 `_runtimeDataModel` 读，最可靠。
+ */
+function fieldsOf(table: string): Set<string> | null {
+  const rt = (prisma as unknown as {
+    _runtimeDataModel?: {
+      models?: Record<string, { fields?: { name: string }[] }>;
+    };
+  })._runtimeDataModel;
+  const fields = rt?.models?.[table]?.fields;
+  if (Array.isArray(fields)) return new Set(fields.map((f) => f.name));
+  return null;
+}
+
+export const POST = withRoute(async (req) => {
+  const user = await currentUser();
+  if (!user) throw new BizError('请先登录', CODE.UNAUTHORIZED, 401);
+
+  // 注意：NextRequest 的 req.body 是 ReadableStream，不能直接 JSON.parse，必须走 req.json()
+  const body = (await req.json().catch(() => ({}))) as {
+    table?: string;
+    title?: string;
+    dateField?: string;
+    from?: string;
+    to?: string;
+    focus?: string;
+    limit?: number;
+  };
+
+  const table = String(body.table ?? '').trim();
+  if (!table) throw new BizError('请指定要统计的数据表（table）', CODE.BAD_REQUEST);
+  if (BLOCKED_MODELS.has(table)) {
+    throw new BizError(`不允许对 ${table} 生成报告`, CODE.FORBIDDEN, 403);
+  }
+
+  // 校验表名真实存在 —— 防拼错、防注入
+  const delegate = (prisma as unknown as Record<string, unknown>)[table] as Delegate | undefined;
+  if (!delegate || typeof delegate.findMany !== 'function') {
+    throw new BizError(`数据表 ${table} 不存在，请检查 Prisma 模型名`, CODE.BAD_REQUEST);
+  }
+
+  const limit = Math.min(Math.max(Number(body.limit) || 200, 1), 1000);
+  const modelFields = fieldsOf(table);
+  const has = (f: string) => (modelFields ? modelFields.has(f) : true);
+
+  const where: Record<string, unknown> = {};
+  // deletedAt 只存在于有软删的表上；无条件过滤会让 OperationLog 这类表直接报错
+  if (has('deletedAt')) where.deletedAt = null;
+
+  const dateField = body.dateField ? String(body.dateField) : null;
+  if (dateField && !has(dateField)) {
+    throw new BizError(`数据表 ${table} 没有字段 ${dateField}`, CODE.BAD_REQUEST);
+  }
+  if (dateField && (body.from || body.to)) {
+    const range: Record<string, Date> = {};
+    if (body.from) range.gte = new Date(`${body.from}T00:00:00`);
+    if (body.to) range.lte = new Date(`${body.to}T23:59:59`);
+    where[dateField] = range;
+  }
+
+  const rows = await delegate.findMany({ where, take: limit });
+  if (!rows.length) {
+    throw new BizError(
+      '该时间段内没有数据，无法生成报告。请调整日期范围，或先补充演示数据。',
+      CODE.BAD_REQUEST
+    );
+  }
+
+  // 把数据压成紧凑 JSON，避免上下文爆掉
+  const payload = rows
+    .map((r) => {
+      const keep: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(r)) {
+        if (k === 'password' || k === 'deletedAt') continue;
+        if (v instanceof Date) keep[k] = v.toISOString().slice(0, 10);
+        else if (typeof v === 'object' && v !== null) keep[k] = '…';
+        else keep[k] = v;
+      }
+      return JSON.stringify(keep);
+    })
+    .join('\n');
+
+  const title = String(body.title ?? '业务报告');
+  const focus = String(body.focus ?? '客观汇总，突出重点与需要关注的问题');
+
+  const report = cleanAiText(
+    await aiChat({
+      system:
+        '你是一名严谨的业务分析人员。你会根据给定的真实业务数据写报告，' +
+        '不编造数据，不夸大，所有结论都能在数据里找到依据。输出 Markdown 格式中文报告。',
+      messages: [
+        {
+          role: 'user',
+          content:
+            `请根据下面的数据写一份《${title}》。\n\n` +
+            `写作要求：\n` +
+            `- ${focus}\n` +
+            `- 结构：一段总体概述 + 一个 Markdown 表格（关键指标）+ 2~4 条要点分析 + 下一步建议\n` +
+            `- 语言平实，不要套话，不要用"赋能""闭环"这类空词\n` +
+            `- 只使用下面出现的数据，不要编造任何数字\n\n` +
+            `数据来源表：${table}，共 ${rows.length} 条。\n` +
+            `${body.from ? `统计区间：${body.from} 至 ${body.to}\n` : ''}\n` +
+            `数据如下（每行一条 JSON）：\n${payload}`,
+        },
+      ],
+      maxTokens: 1400,
+      temperature: 0.3,
+    })
+  );
+
+  void audit({
+    module: 'AI 报告',
+    action: '生成',
+    method: req.method,
+    path: req.url,
+    detail: `表=${table} 行数=${rows.length} 标题=${title}`,
+    userId: user.id,
+    username: user.username,
+  });
+
+  return ok({
+    report,
+    rows: rows.length,
+    title,
+    model: process.env.AI_MODEL ?? 'qwen3.8-27b-gsq',
+    generatedAt: new Date().toISOString(),
+  });
+});

package/resources/src/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,3 @@
+import { handlers } from '@/auth';
+
+export const { GET, POST } = handlers;

package/resources/src/app/api/auth/change-password/route.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import bcrypt from 'bcryptjs';
+import { BizError, CODE, audit, clientInfo, ok, withRoute } from '@/lib/api';
+import { prisma } from '@/lib/prisma';
+import { requireUser } from '@/auth';
+import { zField } from '@/lib/zodField';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 修改密码（需登录）。
+ *
+ * 管理员重置密码后 mustChangePassword = 1，登录会被强制带到 /change-password，
+ * 这个接口负责校验原密码、写入新密码并清掉标记。
+ */
+
+const schema = z.object({
+  oldPassword: z.string().min(1, '请输入原密码'),
+  newPassword: zField('password', { label: '新密码' }),
+});
+
+export const POST = withRoute(async (req) => {
+  const current = await requireUser();
+  const parsed = schema.parse(await req.json());
+
+  const user = await prisma.user.findFirst({ where: { id: current.id, deletedAt: null } });
+  if (!user) throw new BizError('账号不存在', CODE.NOT_FOUND);
+  if (!(await bcrypt.compare(parsed.oldPassword, user.password))) {
+    throw new BizError('原密码不正确', CODE.BAD_REQUEST);
+  }
+  if (await bcrypt.compare(parsed.newPassword, user.password)) {
+    throw new BizError('新密码不能与原密码相同', CODE.BAD_REQUEST);
+  }
+
+  await prisma.user.update({
+    where: { id: user.id },
+    data: {
+      password: await bcrypt.hash(parsed.newPassword, 10),
+      mustChangePassword: 0,
+    },
+  });
+
+  const { ip, userAgent } = clientInfo(req);
+  await audit({
+    userId: user.id,
+    username: user.username,
+    module: '账号安全',
+    action: '修改密码',
+    method: 'POST',
+    path: req.nextUrl.pathname,
+    targetId: user.id,
+    ip,
+    userAgent,
+  });
+
+  return ok(null, '密码修改成功，请使用新密码重新登录');
+});

package/resources/src/app/api/auth/forgot/route.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import bcrypt from 'bcryptjs';
+import { BizError, CODE, audit, clientInfo, ok, withRoute } from '@/lib/api';
+import { prisma } from '@/lib/prisma';
+import { zField } from '@/lib/zodField';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 忘记密码 —— 密保问题自助找回（不需要登录）。
+ *
+ * GET  /api/auth/forgot?username=xxx   取该账号的密保问题
+ * POST /api/auth/forgot                校验密保答案并设置新密码
+ *
+ * 答案和密码都只存 bcrypt 哈希。密保答案熵低，加一层内存限流：
+ * 同一账号 10 分钟内最多试 5 次，防止被逐个猜。
+ */
+
+const MAX_ATTEMPTS = 5;
+const WINDOW_MS = 10 * 60 * 1000;
+const attempts = new Map<string, { count: number; resetAt: number }>();
+
+/** 返回 true = 已超限，本次直接拒绝 */
+function hitLimit(key: string): boolean {
+  const now = Date.now();
+  const rec = attempts.get(key);
+  if (!rec || rec.resetAt <= now) {
+    attempts.set(key, { count: 1, resetAt: now + WINDOW_MS });
+    return false;
+  }
+  if (rec.count >= MAX_ATTEMPTS) return true;
+  rec.count += 1;
+  return false;
+}
+
+export const GET = withRoute(async (req) => {
+  const username = (req.nextUrl.searchParams.get('username') ?? '').trim();
+  if (!username) throw new BizError('请输入用户名', CODE.BAD_REQUEST);
+
+  const user = await prisma.user.findFirst({
+    where: { username, deletedAt: null },
+    select: { username: true, status: true, securityQuestion: true, securityAnswerHash: true },
+  });
+  if (!user) throw new BizError('账号不存在，请核对用户名', CODE.NOT_FOUND);
+  if (user.status !== 1) throw new BizError('该账号已被停用，请联系管理员', CODE.FORBIDDEN, 403);
+
+  // 只有问题和答案都在才算「已设置密保」，防止数据残缺把用户卡死
+  const question = user.securityQuestion && user.securityAnswerHash ? user.securityQuestion : null;
+  return ok({ username: user.username, question });
+});
+
+const resetSchema = z.object({
+  username: zField('username', { label: '用户名' }),
+  answer: z.string().trim().min(1, '请输入密保答案').max(100, '答案过长'),
+  newPassword: zField('password', { label: '新密码' }),
+});
+
+export const POST = withRoute(async (req) => {
+  const parsed = resetSchema.parse(await req.json());
+  const key = parsed.username.toLowerCase();
+
+  if (hitLimit(key)) {
+    throw new BizError('密保答案尝试次数过多，请 10 分钟后再试，或改用人工申诉', CODE.BAD_REQUEST);
+  }
+
+  const user = await prisma.user.findFirst({ where: { username: parsed.username, deletedAt: null } });
+  if (!user) throw new BizError('账号不存在，请核对用户名', CODE.NOT_FOUND);
+  if (user.status !== 1) throw new BizError('该账号已被停用，请联系管理员', CODE.FORBIDDEN, 403);
+  if (!user.securityQuestion || !user.securityAnswerHash) {
+    throw new BizError('该账号未设置密保问题，请在忘记密码页使用「人工申诉」', CODE.BAD_REQUEST);
+  }
+
+  const matched = await bcrypt.compare(parsed.answer, user.securityAnswerHash);
+  if (!matched) throw new BizError('密保答案不正确', CODE.BAD_REQUEST);
+
+  // 用户自己设置的密码，不需要再强制改密
+  await prisma.user.update({
+    where: { id: user.id },
+    data: { password: await bcrypt.hash(parsed.newPassword, 10), mustChangePassword: 0 },
+  });
+  attempts.delete(key);
+
+  const { ip, userAgent } = clientInfo(req);
+  await audit({
+    userId: user.id,
+    username: user.username,
+    module: '账号安全',
+    action: '密保找回密码',
+    method: 'POST',
+    path: req.nextUrl.pathname,
+    targetId: user.id,
+    detail: { username: user.username },
+    ip,
+    userAgent,
+  });
+
+  return ok(null, '密码已重置，请使用新密码登录');
+});

package/resources/src/app/api/auth/register/route.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import bcrypt from 'bcryptjs';
+import { BizError, CODE, audit, clientInfo, ok, withRoute } from '@/lib/api';
+import { prisma } from '@/lib/prisma';
+import { isRegistrationEnabled } from '@/lib/system-config';
+import { zField, zNullableField } from '@/lib/zodField';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 自助注册（不需要登录）。
+ *
+ * POST /api/auth/register   用户名 + 姓名 + 密码（手机号/邮箱选填）
+ *
+ * 与「管理员在用户管理页建号」的分工：
+ *   - 这里只建**裸账号**：启用状态、无部门、无角色、非超管。
+ *     能不能用、能用哪些功能，由管理员事后在用户管理里分配角色决定 ——
+ *     自动塞一个默认角色看着贴心，反而会让「谁批准了这个账号」说不清。
+ *   - 用户名唯一性是**全局**的（软删账号仍占名），与管理员建号同一把尺子。
+ *
+ * 滥用防护：同一 IP 10 分钟内最多 5 次（与忘记密码同一思路，
+ * 内存计数，重启清零 —— 防脚本刷号，不防真人手动慢慢注册）。
+ */
+
+const MAX_PER_IP = 5;
+const WINDOW_MS = 10 * 60 * 1000;
+const ipHits = new Map<string, { count: number; resetAt: number }>();
+
+function overIpLimit(ip: string): boolean {
+  const now = Date.now();
+  const rec = ipHits.get(ip);
+  if (!rec || rec.resetAt <= now) {
+    ipHits.set(ip, { count: 1, resetAt: now + WINDOW_MS });
+    return false;
+  }
+  if (rec.count >= MAX_PER_IP) return true;
+  rec.count += 1;
+  return false;
+}
+
+const registerSchema = z.object({
+  username: zField('username', { label: '用户名' }),
+  password: zField('password', { label: '密码' }),
+  name: zField('name', { label: '姓名' }),
+  phone: zNullableField('phone', { label: '手机号' }),
+  email: zNullableField('email', { label: '邮箱' }),
+});
+
+export const POST = withRoute(async (req) => {
+  // 开关关着时直接拒：注册入口在登录页是隐藏的，但接口不能假设前端一定听话
+  if (!(await isRegistrationEnabled())) {
+    throw new BizError('注册功能暂未开放，请联系管理员', CODE.FORBIDDEN, 403);
+  }
+
+  const { ip } = clientInfo(req);
+  if (overIpLimit(ip)) {
+    // 与忘记密码的限流同一档处理：业务码走 BAD_REQUEST，传输层 429
+    throw new BizError('注册尝试过于频繁，请稍后再试', CODE.BAD_REQUEST, 429);
+  }
+
+  const parsed = registerSchema.parse(await req.json());
+
+  // 与管理端建号一致：全局唯一（软删账号仍占用用户名），不能带 deletedAt 条件
+  const exists = await prisma.user.findUnique({ where: { username: parsed.username } });
+  if (exists) throw new BizError('用户名已存在', CODE.CONFLICT);
+
+  const created = await prisma.user.create({
+    data: {
+      username: parsed.username,
+      password: await bcrypt.hash(parsed.password, 10),
+      name: parsed.name,
+      phone: parsed.phone || null,
+      email: parsed.email || null,
+      status: 1,
+      isSuper: 0,
+      // 不设部门 / 不设角色 / 不设密保：都由管理员在用户管理里补
+    },
+    select: { id: true, username: true },
+  });
+
+  await audit({
+    userId: created.id,
+    username: created.username,
+    module: '用户管理',
+    action: '注册',
+    method: 'POST',
+    path: req.nextUrl.pathname,
+    targetId: created.id,
+    detail: { username: parsed.username, name: parsed.name, source: 'self-service' },
+    ip,
+    userAgent: clientInfo(req).userAgent,
+  });
+
+  return ok({ id: created.id, username: created.username }, '注册成功，请使用新账号登录');
+});

package/resources/src/app/api/auth/register-config/route.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { BizError, CODE, audit, clientInfo, ok, withRoute } from '@/lib/api';
+import { requireUser } from '@/auth';
+import { isRegistrationEnabled, setRegistrationEnabled } from '@/lib/system-config';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 注册开关。
+ *
+ * GET  /api/auth/register-config   读开关（公开）—— 登录页要依它决定显不显示注册入口，
+ *                                  注册页自身也要依它决定显示表单还是「未开放」
+ * PUT  /api/auth/register-config   切开关（**仅超级管理员**）—— 用户管理页的注册设置卡片
+ *
+ * 为什么 GET 公开：开关本身不是敏感信息（登录页人人都要看），
+ * 敏感的是「谁能改」。改的口子只认 isSuper，不新增权限码 ——
+ * 权限码是给角色授权用的，而这个开关按需求只归超管。
+ */
+
+const toggleSchema = z.object({
+  enabled: z.boolean(),
+});
+
+export const GET = withRoute(async () => {
+  return ok({ enabled: await isRegistrationEnabled() });
+});
+
+export const PUT = withRoute(async (req) => {
+  const user = await requireUser();
+  if (!user.isSuper) {
+    throw new BizError('只有超级管理员可以修改注册开关', CODE.FORBIDDEN, 403);
+  }
+
+  const parsed = toggleSchema.parse(await req.json());
+  await setRegistrationEnabled(parsed.enabled);
+
+  const { ip, userAgent } = clientInfo(req);
+  await audit({
+    userId: user.id,
+    username: user.username,
+    module: '用户管理',
+    action: '修改注册开关',
+    method: 'PUT',
+    path: req.nextUrl.pathname,
+    detail: { enabled: parsed.enabled },
+    ip,
+    userAgent,
+  });
+
+  return ok({ enabled: parsed.enabled }, parsed.enabled ? '注册功能已开放' : '注册功能已关闭');
+});

package/resources/src/app/api/badges/route.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ok, withRoute } from '@/lib/api';
+import { requireUser } from '@/auth';
+import { getUserMenuTree } from '@/lib/menu-service';
+import { ackBadge, collectBadges } from '@/lib/badge-count';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 侧边栏徽标接口。
+ *
+ * GET  /api/badges        → { '/feedback': 3 }   当前用户所有菜单徽标
+ * POST /api/badges {path} → 同上，但先把该页标记为已读再返回
+ *
+ * 为什么不建 SSE / WebSocket 推送：
+ *   待办数字的变化频率是以"分钟"计的，不是聊天消息。60 秒轮询 + 回到前台刷新，
+ *   代价是一个几乎不耗资源的 count 查询，换来的是"断线、多标签页、休眠唤醒"
+ *   全都不用额外处理。这套骨架的定位是比赛演示与内网部署，简单可靠优先。
+ *
+ * 为什么 path 而不是 menuId：菜单重跑 seed 会换 id，path 稳定；
+ * 而且前端菜单树里天然有 path，不用为徽标额外传一份菜单 id 映射。
+ */
+export const GET = withRoute(async () => {
+  const user = await requireUser();
+  const menus = await getUserMenuTree(user);
+  return ok(await collectBadges(user, menus));
+});
+
+const ackSchema = z.object({
+  path: z.string().trim().min(1, '缺少 path'),
+});
+
+/** 进入某页面后调用：把"未读"类计数清掉，并返回最新计数 */
+export const POST = withRoute(async (req) => {
+  const user = await requireUser();
+  const { path } = ackSchema.parse(await req.json().catch(() => ({})));
+  const menus = await getUserMenuTree(user);
+  return ok(await ackBadge(user, menus, path));
+});

package/resources/src/app/api/depts/[id]/route.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import { BizError, CODE, audit, clientInfo, ok, withRoute } from '@/lib/api';
+import { prisma } from '@/lib/prisma';
+import { requireUser } from '@/auth';
+import { P, requirePerm } from '@/lib/rbac';
+
+export const dynamic = 'force-dynamic';
+
+const deptSchema = z.object({
+  name: z.string().trim().min(1, '部门名称必填').max(32),
+  code: z
+    .string()
+    .trim()
+    .min(2, '部门编码至少 2 个字符')
+    .max(32)
+    .regex(/^[A-Za-z][A-Za-z0-9_-]*$/, '编码需以字母开头，仅含字母/数字/下划线/短横线'),
+  parentId: z.string().trim().nullish(),
+  sort: z.coerce.number().int().min(0).default(0),
+  status: z.coerce.number().int().min(0).max(1).default(1),
+  remark: z.string().max(200).nullish(),
+});
+
+type Ctx = { params: Promise<{ id: string }> };
+
+/**
+ * 判断 candidate 是不是 id 的后代（用于禁止把父级设成自己的子孙，否则树会成环）
+ */
+async function isDescendant(id: string, candidate: string) {
+  let cur: string | null = candidate;
+  const guard = new Set<string>();
+  while (cur) {
+    if (cur === id) return true;
+    if (guard.has(cur)) return true; // 脏数据成环时直接当作是，拒绝操作
+    guard.add(cur);
+    const row: { parentId: string | null } | null = await prisma.department.findUnique({
+      where: { id: cur },
+      select: { parentId: true },
+    });
+    cur = row?.parentId ?? null;
+  }
+  return false;
+}
+
+/** PUT /api/depts/[id] —— 更新部门 */
+export const PUT = withRoute<Ctx>(async (req, ctx) => {
+  const user = await requireUser();
+  requirePerm(user, P.deptEdit);
+
+  const { id } = await ctx.params;
+  const exist = await prisma.department.findUnique({ where: { id } });
+  if (!exist) throw new BizError('部门不存在', CODE.NOT_FOUND);
+
+  const parsed = deptSchema.parse(await req.json());
+  const parentId = parsed.parentId || null;
+
+  if (parentId) {
+    if (parentId === id) throw new BizError('上级部门不能是自己');
+    if (await isDescendant(id, parentId)) {
+      throw new BizError('上级部门不能是自己的下级，否则会形成循环');
+    }
+    const parent = await prisma.department.findUnique({
+      where: { id: parentId },
+      select: { id: true },
+    });
+    if (!parent) throw new BizError('上级部门不存在');
+  }
+
+  const dup = await prisma.department.findFirst({ where: { code: parsed.code, NOT: { id } } });
+  if (dup) throw new BizError('部门编码已存在', CODE.CONFLICT);
+
+  await prisma.department.update({
+    where: { id },
+    data: {
+      name: parsed.name,
+      code: parsed.code,
+      parentId,
+      sort: parsed.sort,
+      status: parsed.status,
+      remark: parsed.remark || null,
+    },
+  });
+
+  const { ip, userAgent } = clientInfo(req);
+  await audit({
+    userId: user.id,
+    username: user.username,
+    module: '部门管理',
+    action: '修改',
+    method: 'PUT',
+    path: req.nextUrl.pathname,
+    targetId: id,
+    detail: { code: parsed.code, name: parsed.name, parentId },
+    ip,
+    userAgent,
+  });
+
+  return ok({ id }, '保存成功');
+});
+
+/**
+ * DELETE /api/depts/[id] —— 删除部门
+ *
+ * 有子部门 / 有用户 / 有员工时**不允许删**：
+ * 直接删会把用户和员工的外键置空，形成"孤儿数据"，比报错难查得多。
+ */
+export const DELETE = withRoute<Ctx>(async (req, ctx) => {
+  const user = await requireUser();
+  requirePerm(user, P.deptDel);
+
+  const { id } = await ctx.params;
+  const exist = await prisma.department.findUnique({
+    where: { id },
+    include: { _count: { select: { children: true, users: true, employees: true } } },
+  });
+  if (!exist) throw new BizError('部门不存在', CODE.NOT_FOUND);
+
+  const { children, users, employees } = exist._count;
+  if (children > 0) {
+    throw new BizError(`该部门下还有 ${children} 个子部门，请先删除或移走子部门`);
+  }
+  if (users > 0 || employees > 0) {
+    const parts: string[] = [];
+    if (users) parts.push(`${users} 个用户`);
+    if (employees) parts.push(`${employees} 名员工`);
+    throw new BizError(`该部门下还有 ${parts.join('、')}，请先调整归属再删除`);
+  }
+
+  await prisma.department.delete({ where: { id } });
+
+  const { ip, userAgent } = clientInfo(req);
+  await audit({
+    userId: user.id,
+    username: user.username,
+    module: '部门管理',
+    action: '删除',
+    method: 'DELETE',
+    path: req.nextUrl.pathname,
+    targetId: id,
+    detail: { code: exist.code, name: exist.name },
+    ip,
+    userAgent,
+  });
+
+  return ok({ id }, '已删除');
+});