[Snow Team] express-types: auto-commit work

apps/backend/src/routes/admin/shared.ts

@@ -1,23 +1,10 @@
+import type { Request, Response, NextFunction } from 'express'
 import { requireAdminRole, verifyAdminSessionToken } from '../../services/admin/admin-auth-service.js'
 import { writeAdminAuditLog } from '../../services/admin/admin-audit-service.js'
 import { buildSuccessPayload, createHttpError, sendRouteError } from '../../utils/http.js'
 import { logWarn } from '../../utils/logger.js'
 import type { AdminSession } from '../../services/admin/admin-auth-service.js'
 
-type NextFunction = (error?: unknown) => void
-type ExpressResponse = {
-  json: (body: unknown) => unknown
-  sendFile: (path: string) => unknown
-}
-export type AdminExpressRequest = {
-  headers: { authorization?: string | string[] }
-  body?: any
-  params?: Record<string, string | undefined>
-  query?: Record<string, unknown>
-  adminSession?: AdminSession | null
-  [key: string]: unknown
-}
-
 type AdminAuditPayload = {
   action?: string
   targetType?: string
@@ -29,7 +16,7 @@ type AdminJsonHandlerOptions = {
   successMessage?: string
   errorMessage?: string
   scope?: string
-  audit?: (req: AdminExpressRequest, data: unknown) => AdminAuditPayload | null | undefined
+  audit?: (req: Request, data: unknown) => AdminAuditPayload | null | undefined
 }
 
 type AdminFileHandlerOptions = {
@@ -38,10 +25,10 @@ type AdminFileHandlerOptions = {
 }
 
 export function createJsonHandler(
-  action: (req: AdminExpressRequest, res: ExpressResponse) => unknown | Promise<unknown>,
+  action: (req: Request, res: Response) => unknown | Promise<unknown>,
   { successMessage = 'ok', errorMessage, scope, audit }: AdminJsonHandlerOptions = {},
 ) {
-  return async (req, res) => {
+  return async (req: Request, res: Response): Promise<void> => {
     try {
       const data = await action(req, res)
       await recordAdminAudit(req.adminSession, req, data, audit)
@@ -53,10 +40,10 @@ export function createJsonHandler(
 }
 
 export function createFileHandler(
-  action: (req: AdminExpressRequest, res: ExpressResponse) => string | Promise<string>,
+  action: (req: Request, res: Response) => string | Promise<string>,
   { errorMessage, scope }: AdminFileHandlerOptions = {},
 ) {
-  return async (req, res) => {
+  return async (req: Request, res: Response): Promise<void> => {
     try {
       const filePath = await action(req, res)
       res.sendFile(filePath)
@@ -66,7 +53,7 @@ export function createFileHandler(
   }
 }
 
-export async function requireAdminSession(req: AdminExpressRequest, res: ExpressResponse, next: NextFunction) {
+export async function requireAdminSession(req: Request, res: Response, next: NextFunction): Promise<void> {
   try {
     req.adminSession = await verifyAdminSessionToken(extractBearerToken(req))
     next()
@@ -76,7 +63,7 @@ export async function requireAdminSession(req: AdminExpressRequest, res: Express
 }
 
 export function requireAdminRoles(allowedRoles: string[]) {
-  return (req, res, next) => {
+  return (req: Request, res: Response, next: NextFunction): void => {
     try {
       requireAdminRole(req.adminSession, allowedRoles)
       next()
@@ -88,7 +75,7 @@ export function requireAdminRoles(allowedRoles: string[]) {
 
 async function recordAdminAudit(
   session: AdminSession | null | undefined,
-  req: AdminExpressRequest,
+  req: Request,
   data: unknown,
   audit: AdminJsonHandlerOptions['audit'],
 ) {
@@ -114,7 +101,7 @@ async function recordAdminAudit(
   }
 }
 
-export function extractBearerToken(req: AdminExpressRequest) {
+export function extractBearerToken(req: Request): string {
   const authorization = String(req.headers.authorization || '').trim()
   const matched = authorization.match(/^Bearer\s+(.+)$/i)
 

apps/backend/src/routes/admin/tasks.ts

@@ -1,4 +1,4 @@
-import { Router } from 'express'
+import { Router } from "express";
 
 import {
   closeAdminTask,
@@ -14,378 +14,420 @@ import {
   releaseAdminTaskInventory,
   returnNumberAdminTaskKuaishouCloudFulfillment,
   retryAdminTask,
-} from '../../services/admin/admin-write-service.js'
+} from "../../services/admin/admin-write-service.js";
 import {
   getAdminTaskDetail,
   getAdminTaskScreenshotPath,
   getAdminTasks,
-} from '../../services/admin/admin-read-service.js'
-import { createFileHandler, createJsonHandler, requireAdminRoles } from './shared.js'
-import type { AdminExpressRequest } from './shared.js'
+} from "../../services/admin/admin-read-service.js";
+import {
+  createFileHandler,
+  createJsonHandler,
+  requireAdminRoles,
+} from "./shared.js";
+import type { Request } from "express";
 import type {
   AdminTaskKuaishouCloudDispatchRouteBody,
   AdminTaskManualDispatchRouteBody,
   AdminTaskRouteParams,
   AdminTaskRouteQuery,
-} from '../../types/admin-route-inputs.js'
+} from "../../types/admin-route-inputs.js";
 import type {
   AdminTaskActionResponse,
   AdminTaskBindingReleaseResponse,
   AdminTaskManualDispatchResponse,
-} from '../../types/admin-write-models.js'
+} from "../../types/admin-write-models.js";
 
-const router = Router()
+const router = Router();
 
-function getTaskId(req: AdminExpressRequest): string | undefined {
-  return (req.params as AdminTaskRouteParams).taskId
+function getTaskId(req: Request): string | undefined {
+  return (req.params as AdminTaskRouteParams).taskId;
 }
 
-function getBindingId(req: AdminExpressRequest): string | undefined {
-  return (req.params as AdminTaskRouteParams).bindingId
+function getBindingId(req: Request): string | undefined {
+  return (req.params as AdminTaskRouteParams).bindingId;
 }
 
-router.get('/tasks', createJsonHandler(
-  (req) => getAdminTasks(
-    req.query as AdminTaskRouteQuery,
-    req.adminSession || null,
-  ),
-  {
-    successMessage: 'ok',
-    errorMessage: '读取任务列表失败',
-    scope: '[admin/tasks]',
-  },
-))
+router.get(
+  "/tasks",
+  createJsonHandler(
+    (req) =>
+      getAdminTasks(req.query as AdminTaskRouteQuery, req.adminSession || null),
+    {
+      successMessage: "ok",
+      errorMessage: "读取任务列表失败",
+      scope: "[admin/tasks]",
+    }
+  )
+);
 
-router.get('/tasks/:taskId', createJsonHandler(
-  (req) => getAdminTaskDetail(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: 'ok',
-    errorMessage: '读取任务详情失败',
-    scope: '[admin/tasks/:taskId]',
-  },
-))
+router.get(
+  "/tasks/:taskId",
+  createJsonHandler(
+    (req) => getAdminTaskDetail(getTaskId(req), req.adminSession || null),
+    {
+      successMessage: "ok",
+      errorMessage: "读取任务详情失败",
+      scope: "[admin/tasks/:taskId]",
+    }
+  )
+);
 
-router.get('/tasks/:taskId/screenshot', createFileHandler(
-  (req) => getAdminTaskScreenshotPath(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    errorMessage: '读取任务截图失败',
-    scope: '[admin/tasks/:taskId/screenshot]',
-  },
-))
+router.get(
+  "/tasks/:taskId/screenshot",
+  createFileHandler(
+    (req) =>
+      getAdminTaskScreenshotPath(getTaskId(req), req.adminSession || null),
+    {
+      errorMessage: "读取任务截图失败",
+      scope: "[admin/tasks/:taskId/screenshot]",
+    }
+  )
+);
 
-router.post('/tasks/:taskId/retry', requireAdminRoles(['admin', 'operator']), createJsonHandler(
-  (req) => retryAdminTask(getTaskId(req)),
-  {
-    successMessage: '任务已重试',
-    errorMessage: '重试任务失败',
-    scope: '[admin/tasks/:taskId/retry]',
-  },
-))
+router.post(
+  "/tasks/:taskId/retry",
+  requireAdminRoles(["admin", "operator"]),
+  createJsonHandler((req) => retryAdminTask(getTaskId(req)), {
+    successMessage: "任务已重试",
+    errorMessage: "重试任务失败",
+    scope: "[admin/tasks/:taskId/retry]",
+  })
+);
 
-router.post('/tasks/:taskId/release-inventory', requireAdminRoles(['admin']), createJsonHandler(
-  (req) => releaseAdminTaskInventory(getTaskId(req)),
-  {
-    successMessage: '库存凭据已释放',
-    errorMessage: '释放库存凭据失败',
-    scope: '[admin/tasks/:taskId/release-inventory]',
+router.post(
+  "/tasks/:taskId/release-inventory",
+  requireAdminRoles(["admin"]),
+  createJsonHandler((req) => releaseAdminTaskInventory(getTaskId(req)), {
+    successMessage: "库存凭据已释放",
+    errorMessage: "释放库存凭据失败",
+    scope: "[admin/tasks/:taskId/release-inventory]",
     audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
+      const result = data as AdminTaskActionResponse;
       return {
-        action: 'task_release_inventory',
-        targetType: 'task',
+        action: "task_release_inventory",
+        targetType: "task",
         targetId: String(getTaskId(req)),
         data: {
           taskId: result.task.taskId,
           taskNo: result.task.taskNo,
           inventoryItemId: result.task.inventoryItemId,
         },
-      }
+      };
     },
-  },
-))
+  })
+);
 
-router.post('/tasks/:taskId/inventory-bindings/:bindingId/release', requireAdminRoles(['admin']), createJsonHandler(
-  (req) => releaseAdminTaskInventoryBinding(
-    getTaskId(req),
-    getBindingId(req),
-  ),
-  {
-    successMessage: '库存绑定已释放',
-    errorMessage: '释放库存绑定失败',
-    scope: '[admin/tasks/:taskId/inventory-bindings/:bindingId/release]',
-    audit: (req, data) => {
-      const result = data as AdminTaskBindingReleaseResponse
-      return {
-        action: 'task_release_inventory_binding',
-        targetType: 'task_inventory_binding',
-        targetId: String(getBindingId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          bindingId: result.bindingId,
-          inventoryItemId: result.inventoryItemId,
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/inventory-bindings/:bindingId/release",
+  requireAdminRoles(["admin"]),
+  createJsonHandler(
+    (req) =>
+      releaseAdminTaskInventoryBinding(getTaskId(req), getBindingId(req)),
+    {
+      successMessage: "库存绑定已释放",
+      errorMessage: "释放库存绑定失败",
+      scope: "[admin/tasks/:taskId/inventory-bindings/:bindingId/release]",
+      audit: (req, data) => {
+        const result = data as AdminTaskBindingReleaseResponse;
+        return {
+          action: "task_release_inventory_binding",
+          targetType: "task_inventory_binding",
+          targetId: String(getBindingId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            bindingId: result.bindingId,
+            inventoryItemId: result.inventoryItemId,
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/regenerate-claim-link', requireAdminRoles(['admin', 'operator', 'support']), createJsonHandler(
-  (req) => regenerateAdminTaskClaimLink(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '领取链接已重新生成',
-    errorMessage: '重新生成领取链接失败',
-    scope: '[admin/tasks/:taskId/regenerate-claim-link]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      return {
-        action: 'task_regenerate_claim_link',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          primaryClaimTokenId: result.task.primaryClaimTokenId,
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/regenerate-claim-link",
+  requireAdminRoles(["admin", "operator", "support"]),
+  createJsonHandler(
+    (req) =>
+      regenerateAdminTaskClaimLink(getTaskId(req), req.adminSession || null),
+    {
+      successMessage: "领取链接已重新生成",
+      errorMessage: "重新生成领取链接失败",
+      scope: "[admin/tasks/:taskId/regenerate-claim-link]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        return {
+          action: "task_regenerate_claim_link",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            primaryClaimTokenId: result.task.primaryClaimTokenId,
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/support-confirm-role', requireAdminRoles(['admin', 'operator', 'support']), createJsonHandler(
-  (req) => confirmAdminTaskAssistedRole(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '角色已确认',
-    errorMessage: '客服确认角色失败',
-    scope: '[admin/tasks/:taskId/support-confirm-role]',
+router.post(
+  "/tasks/:taskId/support-confirm-role",
+  requireAdminRoles(["admin", "operator", "support"]),
+  createJsonHandler(
+    (req) =>
+      confirmAdminTaskAssistedRole(getTaskId(req), req.adminSession || null),
+    {
+      successMessage: "角色已确认",
+      errorMessage: "客服确认角色失败",
+      scope: "[admin/tasks/:taskId/support-confirm-role]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        return {
+          action: "task_support_confirm_role",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            status: result.task.status,
+          },
+        };
+      },
+    }
+  )
+);
+
+router.post(
+  "/tasks/:taskId/support-redeem",
+  requireAdminRoles(["admin", "operator", "support"]),
+  createJsonHandler(
+    (req) => redeemAdminTaskAssisted(getTaskId(req), req.adminSession || null),
+    {
+      successMessage: "兑换任务已启动",
+      errorMessage: "客服发起兑换失败",
+      scope: "[admin/tasks/:taskId/support-redeem]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        return {
+          action: "task_support_redeem",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            status: result.task.status,
+            deliveryStatus: result.task.deliveryStatus,
+          },
+        };
+      },
+    }
+  )
+);
+
+router.post(
+  "/tasks/:taskId/close",
+  requireAdminRoles(["admin", "operator", "support"]),
+  createJsonHandler((req) => closeAdminTask(getTaskId(req)), {
+    successMessage: "任务已关闭",
+    errorMessage: "关闭任务失败",
+    scope: "[admin/tasks/:taskId/close]",
     audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
+      const result = data as AdminTaskActionResponse;
       return {
-        action: 'task_support_confirm_role',
-        targetType: 'task',
+        action: "task_closed",
+        targetType: "task",
         targetId: String(getTaskId(req)),
         data: {
           taskId: result.task.taskId,
           taskNo: result.task.taskNo,
           status: result.task.status,
         },
-      }
+      };
     },
-  },
-))
+  })
+);
 
-router.post('/tasks/:taskId/support-redeem', requireAdminRoles(['admin', 'operator', 'support']), createJsonHandler(
-  (req) => redeemAdminTaskAssisted(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '兑换任务已启动',
-    errorMessage: '客服发起兑换失败',
-    scope: '[admin/tasks/:taskId/support-redeem]',
+router.post(
+  "/tasks/:taskId/mark-manual-review",
+  requireAdminRoles(["admin", "operator"]),
+  createJsonHandler((req) => markAdminTaskManualReview(getTaskId(req)), {
+    successMessage: "任务已转人工处理",
+    errorMessage: "标记人工处理失败",
+    scope: "[admin/tasks/:taskId/mark-manual-review]",
     audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
+      const result = data as AdminTaskActionResponse;
       return {
-        action: 'task_support_redeem',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          status: result.task.status,
-          deliveryStatus: result.task.deliveryStatus,
-        },
-      }
-    },
-  },
-))
-
-router.post('/tasks/:taskId/close', requireAdminRoles(['admin', 'operator', 'support']), createJsonHandler(
-  (req) => closeAdminTask(getTaskId(req)),
-  {
-    successMessage: '任务已关闭',
-    errorMessage: '关闭任务失败',
-    scope: '[admin/tasks/:taskId/close]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      return {
-        action: 'task_closed',
-        targetType: 'task',
+        action: "task_mark_manual_review",
+        targetType: "task",
         targetId: String(getTaskId(req)),
         data: {
           taskId: result.task.taskId,
           taskNo: result.task.taskNo,
           status: result.task.status,
         },
-      }
+      };
     },
-  },
-))
+  })
+);
 
-router.post('/tasks/:taskId/mark-manual-review', requireAdminRoles(['admin', 'operator']), createJsonHandler(
-  (req) => markAdminTaskManualReview(getTaskId(req)),
-  {
-    successMessage: '任务已转人工处理',
-    errorMessage: '标记人工处理失败',
-    scope: '[admin/tasks/:taskId/mark-manual-review]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      return {
-        action: 'task_mark_manual_review',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          status: result.task.status,
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/complete-manual-dispatch",
+  requireAdminRoles(["admin", "operator"]),
+  createJsonHandler(
+    (req) =>
+      completeAdminTaskManualDispatch(
+        getTaskId(req),
+        req.body as AdminTaskManualDispatchRouteBody,
+        req.adminSession || null
+      ),
+    {
+      successMessage: "人工履约结果已回写",
+      errorMessage: "回写人工履约结果失败",
+      scope: "[admin/tasks/:taskId/complete-manual-dispatch]",
+      audit: (req, data) => {
+        const result = data as AdminTaskManualDispatchResponse;
+        return {
+          action: "task_complete_manual_dispatch",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            outcome: result.outcome,
+            deliveryStatus: result.task.deliveryStatus,
+            resultCode: result.task.resultCode,
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/complete-manual-dispatch', requireAdminRoles(['admin', 'operator']), createJsonHandler(
-  (req) => completeAdminTaskManualDispatch(
-    getTaskId(req),
-    req.body as AdminTaskManualDispatchRouteBody,
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '人工履约结果已回写',
-    errorMessage: '回写人工履约结果失败',
-    scope: '[admin/tasks/:taskId/complete-manual-dispatch]',
-    audit: (req, data) => {
-      const result = data as AdminTaskManualDispatchResponse
-      return {
-        action: 'task_complete_manual_dispatch',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          outcome: result.outcome,
-          deliveryStatus: result.task.deliveryStatus,
-          resultCode: result.task.resultCode,
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/kuaishou-cloud/prepare",
+  requireAdminRoles(["admin", "operator"]),
+  createJsonHandler(
+    (req) =>
+      prepareAdminTaskKuaishouCloudFulfillment(
+        getTaskId(req),
+        req.adminSession || null
+      ),
+    {
+      successMessage: "绑定资源已准备完成",
+      errorMessage: "准备绑定资源失败",
+      scope: "[admin/tasks/:taskId/kuaishou-cloud/prepare]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        return {
+          action: "task_kuaishou_cloud_prepare",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            status: result.task.status,
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/kuaishou-cloud/prepare', requireAdminRoles(['admin', 'operator']), createJsonHandler(
-  (req) => prepareAdminTaskKuaishouCloudFulfillment(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '绑定资源已准备完成',
-    errorMessage: '准备绑定资源失败',
-    scope: '[admin/tasks/:taskId/kuaishou-cloud/prepare]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      return {
-        action: 'task_kuaishou_cloud_prepare',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          status: result.task.status,
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/kuaishou-cloud/refresh-role-info",
+  requireAdminRoles(["admin", "operator", "support"]),
+  createJsonHandler(
+    (req) =>
+      refreshAdminTaskKuaishouCloudRoleInfo(
+        getTaskId(req),
+        req.adminSession || null
+      ),
+    {
+      successMessage: "角色信息已刷新",
+      errorMessage: "刷新角色信息失败",
+      scope: "[admin/tasks/:taskId/kuaishou-cloud/refresh-role-info]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        return {
+          action: "task_kuaishou_cloud_role_info_refreshed",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            status: result.task.status,
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/kuaishou-cloud/refresh-role-info', requireAdminRoles(['admin', 'operator', 'support']), createJsonHandler(
-  (req) => refreshAdminTaskKuaishouCloudRoleInfo(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '角色信息已刷新',
-    errorMessage: '刷新角色信息失败',
-    scope: '[admin/tasks/:taskId/kuaishou-cloud/refresh-role-info]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      return {
-        action: 'task_kuaishou_cloud_role_info_refreshed',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          status: result.task.status,
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/kuaishou-cloud/dispatch",
+  requireAdminRoles(["admin", "operator"]),
+  createJsonHandler(
+    (req) =>
+      dispatchAdminTaskKuaishouCloudFulfillment(
+        getTaskId(req),
+        req.body as AdminTaskKuaishouCloudDispatchRouteBody,
+        req.adminSession || null
+      ),
+    {
+      successMessage: "已完成绑定确认并发货",
+      errorMessage: "执行发货失败",
+      scope: "[admin/tasks/:taskId/kuaishou-cloud/dispatch]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        const body = req.body as AdminTaskKuaishouCloudDispatchRouteBody;
+        return {
+          action: "task_kuaishou_cloud_dispatch",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            status: result.task.status,
+            deliveryStatus: result.task.deliveryStatus,
+            ticketCodeProvided: Boolean(String(body.ticketCode || "").trim()),
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/kuaishou-cloud/dispatch', requireAdminRoles(['admin', 'operator']), createJsonHandler(
-  (req) => dispatchAdminTaskKuaishouCloudFulfillment(
-    getTaskId(req),
-    req.body as AdminTaskKuaishouCloudDispatchRouteBody,
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '已完成绑定确认并发货',
-    errorMessage: '执行发货失败',
-    scope: '[admin/tasks/:taskId/kuaishou-cloud/dispatch]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      const body = req.body as AdminTaskKuaishouCloudDispatchRouteBody
-      return {
-        action: 'task_kuaishou_cloud_dispatch',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          status: result.task.status,
-          deliveryStatus: result.task.deliveryStatus,
-          ticketCodeProvided: Boolean(String(body.ticketCode || '').trim()),
-        },
-      }
-    },
-  },
-))
+router.post(
+  "/tasks/:taskId/kuaishou-cloud/return-number",
+  requireAdminRoles(["admin", "operator"]),
+  createJsonHandler(
+    (req) =>
+      returnNumberAdminTaskKuaishouCloudFulfillment(
+        getTaskId(req),
+        req.adminSession || null
+      ),
+    {
+      successMessage: "号码已退还",
+      errorMessage: "退还号码失败",
+      scope: "[admin/tasks/:taskId/kuaishou-cloud/return-number]",
+      audit: (req, data) => {
+        const result = data as AdminTaskActionResponse;
+        return {
+          action: "task_kuaishou_cloud_return_number",
+          targetType: "task",
+          targetId: String(getTaskId(req)),
+          data: {
+            taskId: result.task.taskId,
+            taskNo: result.task.taskNo,
+            status: result.task.status,
+          },
+        };
+      },
+    }
+  )
+);
 
-router.post('/tasks/:taskId/kuaishou-cloud/return-number', requireAdminRoles(['admin', 'operator']), createJsonHandler(
-  (req) => returnNumberAdminTaskKuaishouCloudFulfillment(
-    getTaskId(req),
-    req.adminSession || null,
-  ),
-  {
-    successMessage: '号码已退还',
-    errorMessage: '退还号码失败',
-    scope: '[admin/tasks/:taskId/kuaishou-cloud/return-number]',
-    audit: (req, data) => {
-      const result = data as AdminTaskActionResponse
-      return {
-        action: 'task_kuaishou_cloud_return_number',
-        targetType: 'task',
-        targetId: String(getTaskId(req)),
-        data: {
-          taskId: result.task.taskId,
-          taskNo: result.task.taskNo,
-          status: result.task.status,
-        },
-      }
-    },
-  },
-))
-
-export default router
+export default router;

apps/backend/src/routes/admin/users.ts

@@ -56,7 +56,7 @@ router.post('/users', createJsonHandler(
 ))
 
 router.post('/users/:userId/role', createJsonHandler(
-  (req) => updateManagedAdminUserRole(req.params.userId, req.body, req.adminSession),
+  (req) => updateManagedAdminUserRole(String(req.params.userId), req.body, req.adminSession),
   {
     successMessage: '用户角色已更新',
     errorMessage: '更新用户角色失败',
@@ -77,7 +77,7 @@ router.post('/users/:userId/role', createJsonHandler(
 ))
 
 router.post('/users/:userId/status', createJsonHandler(
-  (req) => updateManagedAdminUserStatus(req.params.userId, req.body, req.adminSession),
+  (req) => updateManagedAdminUserStatus(String(req.params.userId), req.body, req.adminSession),
   {
     successMessage: '用户状态已更新',
     errorMessage: '更新用户状态失败',
@@ -98,7 +98,7 @@ router.post('/users/:userId/status', createJsonHandler(
 ))
 
 router.post('/users/:userId/inventory-groups', createJsonHandler(
-  (req) => updateManagedAdminUserInventoryGroups(req.params.userId, req.body, req.adminSession),
+  (req) => updateManagedAdminUserInventoryGroups(String(req.params.userId), req.body, req.adminSession),
   {
     successMessage: '用户库存组已更新',
     errorMessage: '更新用户库存组失败',
@@ -119,7 +119,7 @@ router.post('/users/:userId/inventory-groups', createJsonHandler(
 ))
 
 router.post('/users/:userId/reset-password', createJsonHandler(
-  (req) => resetManagedAdminUserPassword(req.params.userId, req.body),
+  (req) => resetManagedAdminUserPassword(String(req.params.userId), req.body),
   {
     successMessage: '用户密码已重置',
     errorMessage: '重置用户密码失败',