jiawei/aiartstudio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 多功能更新

Browse Source
This commit is contained in:
Marcus
2026-04-26 00:39:28 +08:00
parent abd1b03529
commit e26e2f5491
26 changed files with 992 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/api/auth/login.post.ts
+44 -13
View File
@@ -1,8 +1,8 @@
// server/api/auth/login.post.ts
import { consola } from "consola";
import type { IUserLoginData, IUserLoginRequest } from "#shared/types";
import {
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createSuccessResponse,
createUpstreamErrorResponse,
@@ -10,6 +10,7 @@ import {
extractCookieValueFromSetCookie,
newApiFetchRaw,
setNewApiAuthCookies,
toSafeLogError,
upsertUserSnapshot
} from "~~/server/utils";
@@ -28,6 +29,7 @@ interface INewApiLoginUserData extends IUserLoginData {
/** NewAPI 登录结果如果返回额外字段，服务端会在返回前裁剪掉 */
[key: string]: unknown;
}
/**
* 允许从请求体透传给上游的字段列表。
* 只有在这里声明过的字段才会被转发，其余字段一律丢弃，防止参数污染。
@@ -40,11 +42,24 @@ const LOGIN_FIELDS = ["username", "password"] as const satisfies ReadonlyArray<
* POST /api/auth/login
*/
export default defineEventHandler(async (event) => {
const logger = createApiLogger("auth.login");
const requestBody = await readBody<Partial<IUserLoginRequest> | null>(event);
logger.info("开始", {
bodyType: requestBody === null ? "null" : typeof requestBody,
hasUsername: typeof requestBody?.username === "string",
hasPassword: typeof requestBody?.password === "string"
});
// 只接受 JSON 对象或 null，避免数组/字符串等无效 body 被透传到上游。
if (requestBody !== null && typeof requestBody !== "object") {
if (
requestBody !== null &&
(typeof requestBody !== "object" || Array.isArray(requestBody))
) {
clearNewApiAuthCookies(event);
logger.warn("请求体格式错误", {
bodyType: Array.isArray(requestBody) ? "array" : typeof requestBody
});
return createErrorResponse(400, "请求体必须是 JSON 对象");
}
@@ -70,19 +85,28 @@ export default defineEventHandler(async (event) => {
);
const normalized = normalizeLoginResponse(result._data);
const session = extractCookieValueFromSetCookie(result.headers, "session");
logger.info("上游登录返回", {
success: Boolean(normalized.user),
hasSession: Boolean(session)
});
if (!normalized.user) {
// 上游业务失败时同步清理本地旧登录态，避免继续携带坏 cookie。
clearNewApiAuthCookies(event);
logger.warn("登录业务失败", {
upstreamMessage: normalized.message
});
return createErrorResponse(1, normalized.message, result._data ?? null);
}
const session = extractCookieValueFromSetCookie(result.headers, "session");
if (!session) {
// 没有 session 就不能恢复 NewAPI 登录态，必须让前端明确感知失败。
clearNewApiAuthCookies(event);
consola.error(
"/api/auth/login 登录成功但未收到 NewAPI session，请稍后重试"
);
logger.error("登录成功但未收到 NewAPI session", {
userId: normalized.user.id
});
return createErrorResponse(500, "服务器错误，请稍后重试");
}
@@ -94,7 +118,16 @@ export default defineEventHandler(async (event) => {
);
upsertUserSnapshot(normalized.user).catch((error) => {
consola.error("/api/auth/login 保存用户快照失败", error);
logger.error("保存用户快照失败", {
userId: normalized.user?.id,
error: toSafeLogError(error)
});
});
logger.done("成功", {
userId: normalized.user.id,
role: normalized.user.role,
status: normalized.user.status
});
return createSuccessResponse<IUserLoginData>(
@@ -103,7 +136,9 @@ export default defineEventHandler(async (event) => {
);
} catch (error) {
clearNewApiAuthCookies(event);
consola.error("/api/auth/login 登录失败", error);
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "登录失败");
}
});
@@ -112,7 +147,6 @@ export default defineEventHandler(async (event) => {
const normalizeLoginResponse = (
response: NewApiLoginResponse | undefined
): { message: string; user: IUserLoginData | null } => {
consola.info("user data", response);
if (isUser(response)) {
return {
message: "登录成功",
@@ -121,7 +155,6 @@ const normalizeLoginResponse = (
}
if (!isRecord(response)) {
consola.error("/api/auth/login 登录失败：响应不是对象");
return {
message: "登录失败",
user: null
@@ -129,11 +162,9 @@ const normalizeLoginResponse = (
}
const wrapped = response as INewApiWrappedLoginResponse;
const message =
wrapped.message || (wrapped.success ? "登录成功" : "登录失败");
const message = wrapped.message || (wrapped.success ? "登录成功" : "登录失败");
if (wrapped.success !== true || !isUser(wrapped.data)) {
consola.error("/api/auth/login 登录失败：上游返回的数据格式不正确");
return {
message,
user: null
server/api/auth/logout.get.ts
+12 -2
View File
@@ -1,21 +1,31 @@
import type { IUserLogoutData } from "#shared/types";
import {
clearNewApiAuthCookies,
createApiLogger,
createSuccessResponse,
newApiAuthedFetch
newApiAuthedFetch,
toSafeLogError
} from "~~/server/utils";
export default defineEventHandler(async (event) => {
const logger = createApiLogger("auth.logout");
logger.info("开始");
try {
// 带上本站 httpOnly cookie 中的 NewAPI 登录态，请求上游销毁 session。
await newApiAuthedFetch<IUserLogoutData>(event, "/api/user/logout", {
method: "GET"
});
} catch {
logger.info("上游登出成功");
} catch (error) {
// 上游 session 可能已失效，本地仍然必须清理，避免残留坏登录态。
logger.warn("上游登出失败，继续清理本地登录态", {
error: toSafeLogError(error)
});
} finally {
clearNewApiAuthCookies(event);
}
logger.done("成功");
return createSuccessResponse<IUserLogoutData>(null, "登出成功");
});
server/api/auth/me.get.ts
+24 -2
View File
@@ -1,9 +1,11 @@
import type { IUserMeData } from "#shared/types";
import {
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createSuccessResponse,
newApiAuthedFetch,
toSafeLogError,
upsertUserSnapshot
} from "~~/server/utils";
@@ -24,6 +26,9 @@ interface INewApiSelfUserData extends IUserMeData {
}
export default defineEventHandler(async (event) => {
const logger = createApiLogger("auth.me");
logger.info("开始");
try {
// 从本站 httpOnly cookie 读取登录态，并转发给 NewAPI 查询当前用户。
const result = await newApiAuthedFetch<NewApiUserResponse>(
@@ -38,18 +43,35 @@ export default defineEventHandler(async (event) => {
if (!normalized.user) {
// 上游业务失败代表当前 cookie 不再可靠，清理后返回统一 401。
clearNewApiAuthCookies(event);
logger.warn("登录状态无效", {
upstreamMessage: normalized.message
});
return createErrorResponse(401, normalized.message);
}
upsertUserSnapshot(normalized.user).catch(() => {});
upsertUserSnapshot(normalized.user).catch((error) => {
logger.error("保存用户快照失败", {
userId: normalized.user?.id,
error: toSafeLogError(error)
});
});
logger.done("成功", {
userId: normalized.user.id,
role: normalized.user.role,
status: normalized.user.status
});
return createSuccessResponse<IUserMeData>(
normalized.user,
normalized.message
);
} catch {
} catch (error) {
// cookie 缺失或上游鉴权异常时统一视为未登录。
clearNewApiAuthCookies(event);
logger.warn("未登录或登录态失效", {
error: toSafeLogError(error)
});
return createErrorResponse(401, "未登录");
}
});
server/api/auth/ready.get.ts
+24 -1
View File
@@ -1,10 +1,27 @@
import type { IUserReadyData } from "#shared/types";
import { isUnauthorizedError } from "~~/server/utils";
import {
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createSuccessResponse,
createUpstreamErrorResponse,
ensureAiArtStudioToken,
isUnauthorizedError,
toSafeLogError
} from "~~/server/utils";
export default defineEventHandler(async (event) => {
const logger = createApiLogger("auth.ready");
logger.info("开始");
try {
const result = await ensureAiArtStudioToken(event);
logger.done("成功", {
ready: result.ready,
created: result.created
});
return createSuccessResponse<IUserReadyData>(
result,
result.created ? "环境初始化完成" : "环境已准备"
@@ -12,9 +29,15 @@ export default defineEventHandler(async (event) => {
} catch (error) {
if (isUnauthorizedError(error)) {
clearNewApiAuthCookies(event);
logger.warn("未登录或登录态失效", {
error: toSafeLogError(error)
});
return createErrorResponse(401, "未登录");
}
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "环境准备失败");
}
});
server/api/auth/register.post.ts
+29 -6
View File
@@ -1,13 +1,12 @@
// server/api/auth/register.post.ts
import type {
IUserRegisterData,
IUserRegisterRequest
} from "#shared/types";
import type { IUserRegisterData, IUserRegisterRequest } from "#shared/types";
import {
createApiLogger,
createErrorResponse,
createSuccessResponse,
createUpstreamErrorResponse,
newApiFetch
newApiFetch,
toSafeLogError
} from "~~/server/utils";
/**
@@ -26,11 +25,28 @@ const REGISTER_FIELDS = [
* POST /api/auth/register
*/
export default defineEventHandler(async (event) => {
const logger = createApiLogger("auth.register");
const requestBody = await readBody<Partial<IUserRegisterRequest> | null>(
event
);
if (requestBody !== null && typeof requestBody !== "object") {
logger.info("开始", {
bodyType: requestBody === null ? "null" : typeof requestBody,
hasUsername: typeof requestBody?.username === "string",
hasPassword: typeof requestBody?.password === "string",
hasEmail: typeof requestBody?.email === "string",
hasVerificationCode: typeof requestBody?.verification_code === "string",
hasAffCode: typeof requestBody?.aff_code === "string"
});
// 只接受 JSON 对象或 null，避免数组/字符串等无效 body 被透传到上游。
if (
requestBody !== null &&
(typeof requestBody !== "object" || Array.isArray(requestBody))
) {
logger.warn("请求体格式错误", {
bodyType: Array.isArray(requestBody) ? "array" : typeof requestBody
});
return createErrorResponse(400, "请求体必须是 JSON 对象");
}
@@ -51,8 +67,15 @@ export default defineEventHandler(async (event) => {
}
});
logger.done("成功", {
hasResult: Boolean(result)
});
return createSuccessResponse(result, "注册成功");
} catch (error) {
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "注册失败");
}
});
server/api/images/db-health.get.ts
-22
View File
@@ -1,22 +0,0 @@
import { consola } from "consola";
import { prisma } from "~~/server/utils";
export default defineEventHandler(async () => {
const startedAt = Date.now();
try {
await prisma.$queryRaw`SELECT 1`;
return createSuccessResponse(
{
ok: true,
elapsedMs: Date.now() - startedAt
},
"数据库连接正常"
);
} catch (error) {
consola.error("[images.db-health] 数据库连接失败", error);
return createUpstreamErrorResponse(error, "数据库连接失败");
}
});
server/api/images/generate.post.ts
+109 -70
View File
@@ -1,20 +1,29 @@
import { randomUUID } from "node:crypto";
import { consola } from "consola";
import type {
IImageGenerateData,
IImageGenerateRequest
} from "#shared/types/openai";
import {
askImgStream,
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createRunningImageGeneration,
downloadImageAsBase64,
createSuccessResponse,
createUpstreamErrorResponse,
finishImageGenerationFailed,
finishImageGenerationSuccess,
getAiArtStudioTokenKey,
getNewApiUserIdFromCookie,
isUnauthorizedError
getUserArchiveIdentity,
isUnauthorizedError,
toSafeLogError,
uploadImageFromUrl
} from "~~/server/utils";
type ApiLogger = ReturnType<typeof createApiLogger>;
export default defineEventHandler(async (event) => {
const requestId = randomUUID();
const logger = createApiLogger("images.generate");
let stage = "read_body";
const requestBody = await readBody<Partial<IImageGenerateRequest> | null>(
event
@@ -25,87 +34,95 @@ export default defineEventHandler(async (event) => {
requestBody !== null &&
(typeof requestBody !== "object" || Array.isArray(requestBody))
) {
logger.warn("请求体格式错误", {
bodyType: Array.isArray(requestBody) ? "array" : typeof requestBody
});
return createErrorResponse(400, "请求体必须是 JSON 对象");
}
const prompt = requestBody?.prompt?.trim();
if (!prompt) {
logger.warn("缺少提示词");
return createErrorResponse(400, "请输入图片描述");
}
logger.info("开始", {
promptLength: prompt.length
});
let record: { id: bigint; startedAt: Date } | null = null;
try {
consola.info("[images.generate] 开始", {
requestId,
promptLength: prompt.length
});
stage = "read_user_id";
const userId = getNewApiUserIdFromCookie(event);
consola.info("[images.generate] 读取用户成功", {
requestId,
logger.info("读取用户成功", {
userId
});
stage = "create_running_record";
record = await createRunningImageGeneration(userId, prompt);
consola.info("[images.generate] 创建生图记录成功", {
requestId,
logger.info("创建生图记录成功", {
recordId: record.id.toString()
});
stage = "get_api_key";
const apiKey = await getAiArtStudioTokenKey(event);
consola.info("[images.generate] 获取服务端 key 成功", {
requestId,
logger.info("获取服务端 key 成功", {
recordId: record.id.toString()
});
stage = "call_image_api";
const result = await askImg({
stage = "call_image_stream_api";
const result = await askImgStream({
apiKey,
prompt
});
consola.info("[images.generate] 上游生图成功", {
requestId,
logger.info("上游流式生图成功", {
recordId: record.id.toString(),
hasImageUrl: Boolean(result.imageUrl)
hasImageUrl: Boolean(result.imageUrl),
contentLength: getStreamContentLength(result.upstreamResponse),
hasUsage: hasStreamUsage(result.upstreamResponse)
});
stage = "download_image_base64";
const downloadedImage = await downloadGeneratedImage(result.imageUrl);
consola.info("[images.generate] 图片归档下载完成", {
requestId,
stage = "upload_lsky";
const archiveResult = await archiveGeneratedImage({
imageUrl: result.imageUrl,
userId,
recordId: record.id,
createdAt: record.startedAt,
logger
});
logger.info("图床归档完成", {
recordId: record.id.toString(),
hasBase64: Boolean(downloadedImage.base64),
mimeType: downloadedImage.mimeType
hosted: Boolean(archiveResult.hostedImageUrl),
mimeType: archiveResult.imageMimeType
});
stage = "finish_success_record";
await finishImageGenerationSuccess(record.id, record.startedAt, {
imageUrl: result.imageUrl,
imageBase64: downloadedImage.base64,
imageMimeType: downloadedImage.mimeType,
hostedImageUrl: archiveResult.hostedImageUrl,
imageMimeType: archiveResult.imageMimeType,
revisedPrompt: result.revisedPrompt,
upstreamResponse: result.upstreamResponse,
errorMessage: downloadedImage.errorMessage
hostedResponse: archiveResult.hostedResponse,
errorMessage: archiveResult.errorMessage
});
consola.info("[images.generate] 完成", {
requestId,
recordId: record.id.toString()
logger.done("成功", {
recordId: record.id.toString(),
hosted: Boolean(archiveResult.hostedImageUrl)
});
return createSuccessResponse<IImageGenerateData>(
{
imageUrl: result.imageUrl,
hostedImageUrl: archiveResult.hostedImageUrl,
revisedPrompt: result.revisedPrompt
},
"图片生成成功"
);
} catch (error) {
consola.error("[images.generate] 失败", {
requestId,
logger.error("失败", {
stage,
recordId: record?.id.toString() ?? null,
error: toSafeLogError(error)
@@ -114,8 +131,7 @@ export default defineEventHandler(async (event) => {
if (record) {
await finishImageGenerationFailed(record.id, record.startedAt, error).catch(
(recordError) => {
consola.error("[images.generate] 更新失败记录失败", {
requestId,
logger.error("更新失败记录失败", {
recordId: record?.id.toString() ?? null,
error: toSafeLogError(recordError)
});
@@ -132,52 +148,75 @@ export default defineEventHandler(async (event) => {
}
});
/** 图片 URL 仍然可用时，base64 保存失败不阻断本次生成结果 */
const downloadGeneratedImage = async (
imageUrl: string
): Promise<{
base64: string | null;
mimeType: string | null;
const archiveGeneratedImage = async ({
imageUrl,
userId,
recordId,
createdAt,
logger
}: {
imageUrl: string;
userId: number;
recordId: bigint;
createdAt: Date;
logger: ApiLogger;
}): Promise<{
hostedImageUrl: string | null;
imageMimeType: string | null;
hostedResponse: unknown;
errorMessage: string | null;
}> => {
try {
const image = await downloadImageAsBase64(imageUrl);
// 图床归档失败不能阻断本次生成结果，前端仍可使用上游图片 URL。
const identity = await getUserArchiveIdentity(userId);
const uploaded = await uploadImageFromUrl({
imageUrl,
userId,
username: identity.username,
recordId,
createdAt
});
return {
base64: image.base64,
mimeType: image.mimeType,
hostedImageUrl: uploaded.publicUrl,
imageMimeType: uploaded.mimetype,
hostedResponse: uploaded.response,
errorMessage: null
};
} catch (error) {
consola.error("[images.generate] 保存生成图片 base64 失败", {
logger.error("图床归档失败", {
recordId: recordId.toString(),
error: toSafeLogError(error)
});
return {
base64: null,
mimeType: null,
errorMessage: "图片生成成功，但 base64 保存失败"
hostedImageUrl: null,
imageMimeType: null,
hostedResponse: null,
errorMessage: "图片生成成功，但图床归档失败"
};
}
};
const toSafeLogError = (error: unknown) => {
const maybeError = error as {
data?: unknown;
message?: string;
name?: string;
response?: {
_data?: unknown;
status?: number;
};
stack?: string;
status?: number;
statusCode?: number;
};
// 日志只读取流式聚合结果的元信息，不记录完整提示词、key 或图片内容。
const getStreamContentLength = (upstreamResponse: unknown) => {
if (
upstreamResponse &&
typeof upstreamResponse === "object" &&
"content" in upstreamResponse &&
typeof upstreamResponse.content === "string"
) {
return upstreamResponse.content.length;
}
return {
name: maybeError.name,
message: maybeError.message,
status: maybeError.status ?? maybeError.statusCode ?? maybeError.response?.status,
data: maybeError.data ?? maybeError.response?._data ?? null,
stack: maybeError.stack
};
return 0;
};
const hasStreamUsage = (upstreamResponse: unknown) => {
return (
upstreamResponse !== null &&
typeof upstreamResponse === "object" &&
"usage" in upstreamResponse &&
Boolean(upstreamResponse.usage)
);
};
server/api/images/history.get.ts
+30 -1
View File
@@ -1,9 +1,14 @@
import type { IImageHistoryListData } from "#shared/types/openai";
import {
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createSuccessResponse,
createUpstreamErrorResponse,
getNewApiUserIdFromCookie,
isUnauthorizedError,
listImageGenerationHistory
listImageGenerationHistory,
toSafeLogError
} from "~~/server/utils";
const DEFAULT_PAGE = 1;
@@ -11,6 +16,9 @@ const DEFAULT_PAGE_SIZE = 10;
const MAX_PAGE_SIZE = 50;
export default defineEventHandler(async (event) => {
const logger = createApiLogger("images.history.list");
logger.info("开始");
try {
const userId = getNewApiUserIdFromCookie(event);
const query = getQuery(event);
@@ -19,12 +27,27 @@ export default defineEventHandler(async (event) => {
normalizePositiveInt(query.size, DEFAULT_PAGE_SIZE),
MAX_PAGE_SIZE
);
logger.info("查询参数", {
userId,
page,
pageSize
});
const result = await listImageGenerationHistory({
userId,
page,
pageSize
});
logger.done("成功", {
userId,
page,
pageSize,
total: result.total,
itemCount: result.items.length
});
return createSuccessResponse<IImageHistoryListData>(
result,
"获取生图历史成功"
@@ -32,9 +55,15 @@ export default defineEventHandler(async (event) => {
} catch (error) {
if (isUnauthorizedError(error)) {
clearNewApiAuthCookies(event);
logger.warn("未登录或登录态失效", {
error: toSafeLogError(error)
});
return createErrorResponse(401, "未登录");
}
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "获取生图历史失败");
}
});
server/api/images/history/[id].delete.ts
+30 -1
View File
@@ -1,27 +1,56 @@
import {
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createSuccessResponse,
createUpstreamErrorResponse,
getNewApiUserIdFromCookie,
isUnauthorizedError,
softDeleteImageGeneration
softDeleteImageGeneration,
toSafeLogError
} from "~~/server/utils";
export default defineEventHandler(async (event) => {
const logger = createApiLogger("images.history.delete");
logger.info("开始");
try {
const userId = getNewApiUserIdFromCookie(event);
const recordId = parseRecordId(getRouterParam(event, "id"));
logger.info("删除参数", {
userId,
recordId: recordId.toString()
});
const deleted = await softDeleteImageGeneration(userId, recordId);
if (!deleted) {
logger.warn("记录不存在", {
userId,
recordId: recordId.toString()
});
return createErrorResponse(404, "生图记录不存在");
}
logger.done("成功", {
userId,
recordId: recordId.toString()
});
return createSuccessResponse(null, "删除生图记录成功");
} catch (error) {
if (isUnauthorizedError(error)) {
clearNewApiAuthCookies(event);
logger.warn("未登录或登录态失效", {
error: toSafeLogError(error)
});
return createErrorResponse(401, "未登录");
}
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "删除生图记录失败");
}
});
server/api/images/history/[id].get.ts
+32 -1
View File
@@ -1,21 +1,46 @@
import type { IImageHistoryDetail } from "#shared/types/openai";
import {
clearNewApiAuthCookies,
createApiLogger,
createErrorResponse,
createSuccessResponse,
createUpstreamErrorResponse,
getImageGenerationDetail,
getNewApiUserIdFromCookie,
isUnauthorizedError
isUnauthorizedError,
toSafeLogError
} from "~~/server/utils";
export default defineEventHandler(async (event) => {
const logger = createApiLogger("images.history.detail");
logger.info("开始");
try {
const userId = getNewApiUserIdFromCookie(event);
const recordId = parseRecordId(getRouterParam(event, "id"));
logger.info("查询参数", {
userId,
recordId: recordId.toString()
});
const result = await getImageGenerationDetail(userId, recordId);
if (!result) {
logger.warn("记录不存在", {
userId,
recordId: recordId.toString()
});
return createErrorResponse(404, "生图记录不存在");
}
logger.done("成功", {
userId,
recordId: recordId.toString(),
status: result.status,
hasHostedImageUrl: Boolean(result.hostedImageUrl)
});
return createSuccessResponse<IImageHistoryDetail>(
result,
"获取生图详情成功"
@@ -23,9 +48,15 @@ export default defineEventHandler(async (event) => {
} catch (error) {
if (isUnauthorizedError(error)) {
clearNewApiAuthCookies(event);
logger.warn("未登录或登录态失效", {
error: toSafeLogError(error)
});
return createErrorResponse(401, "未登录");
}
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "获取生图详情失败");
}
});
server/api/images/stats.get.ts
+21 -1
View File
@@ -1,15 +1,35 @@
import type { IImageGenerationStatsData } from "#shared/types/openai";
import { getGenerationStats } from "~~/server/utils";
import {
createApiLogger,
createSuccessResponse,
createUpstreamErrorResponse,
getGenerationStats,
toSafeLogError
} from "~~/server/utils";
export default defineEventHandler(async () => {
const logger = createApiLogger("images.stats");
logger.info("开始");
try {
const result = await getGenerationStats();
logger.done("成功", {
totalRequests: result.totalRequests,
successRequests: result.successRequests,
failedRequests: result.failedRequests,
runningRequests: result.runningRequests,
totalImages: result.totalImages
});
return createSuccessResponse<IImageGenerationStatsData>(
result,
"获取生图统计成功"
);
} catch (error) {
logger.error("失败", {
error: toSafeLogError(error)
});
return createUpstreamErrorResponse(error, "获取生图统计失败");
}
});