feat: 新增数据库

server/api/auth/login.post.ts

@@ -9,7 +9,8 @@ import {
   extractCookieMetaFromSetCookie,
   extractCookieValueFromSetCookie,
   newApiFetchRaw,
-  setNewApiAuthCookies
+  setNewApiAuthCookies,
+  upsertUserSnapshot
 } from "~~/server/utils";
 
 interface INewApiWrappedLoginResponse {
@@ -92,6 +93,10 @@ export default defineEventHandler(async (event) => {
       extractCookieMetaFromSetCookie(result.headers, "session")
     );
 
+    upsertUserSnapshot(normalized.user).catch((error) => {
+      consola.error("/api/auth/login 保存用户快照失败", error);
+    });
+
     return createSuccessResponse<IUserLoginData>(
       normalized.user,
       normalized.message

server/api/auth/me.get.ts

@@ -3,7 +3,8 @@ import {
   clearNewApiAuthCookies,
   createErrorResponse,
   createSuccessResponse,
-  newApiAuthedFetch
+  newApiAuthedFetch,
+  upsertUserSnapshot
 } from "~~/server/utils";
 
 interface INewApiWrappedUserResponse {
@@ -40,6 +41,8 @@ export default defineEventHandler(async (event) => {
       return createErrorResponse(401, normalized.message);
     }
 
+    upsertUserSnapshot(normalized.user).catch(() => {});
+
     return createSuccessResponse<IUserMeData>(
       normalized.user,
       normalized.message

server/api/images/db-health.get.ts

@@ -0,0 +1,22 @@
+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

@@ -1,12 +1,21 @@
+import { randomUUID } from "node:crypto";
 import { consola } from "consola";
-
 import type {
   IImageGenerateData,
   IImageGenerateRequest
 } from "#shared/types/openai";
-import { isUnauthorizedError } from "~~/server/utils";
+import {
+  createRunningImageGeneration,
+  downloadImageAsBase64,
+  finishImageGenerationFailed,
+  finishImageGenerationSuccess,
+  getNewApiUserIdFromCookie,
+  isUnauthorizedError
+} from "~~/server/utils";
 
 export default defineEventHandler(async (event) => {
+  const requestId = randomUUID();
+  let stage = "read_body";
   const requestBody = await readBody<Partial<IImageGenerateRequest> | null>(
     event
   );
@@ -24,16 +33,96 @@ export default defineEventHandler(async (event) => {
     return createErrorResponse(400, "请输入图片描述");
   }
 
+  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,
+      userId
+    });
+
+    stage = "create_running_record";
+    record = await createRunningImageGeneration(userId, prompt);
+    consola.info("[images.generate] 创建生图记录成功", {
+      requestId,
+      recordId: record.id.toString()
+    });
+
+    stage = "get_api_key";
     const apiKey = await getAiArtStudioTokenKey(event);
+    consola.info("[images.generate] 获取服务端 key 成功", {
+      requestId,
+      recordId: record.id.toString()
+    });
+
+    stage = "call_image_api";
     const result = await askImg({
       apiKey,
       prompt
     });
+    consola.info("[images.generate] 上游生图成功", {
+      requestId,
+      recordId: record.id.toString(),
+      hasImageUrl: Boolean(result.imageUrl)
+    });
 
-    consola.info("图片生成成功", { prompt, imageUrl: result.imageUrl });
-    return createSuccessResponse<IImageGenerateData>(result, "图片生成成功");
+    stage = "download_image_base64";
+    const downloadedImage = await downloadGeneratedImage(result.imageUrl);
+    consola.info("[images.generate] 图片归档下载完成", {
+      requestId,
+      recordId: record.id.toString(),
+      hasBase64: Boolean(downloadedImage.base64),
+      mimeType: downloadedImage.mimeType
+    });
+
+    stage = "finish_success_record";
+    await finishImageGenerationSuccess(record.id, record.startedAt, {
+      imageUrl: result.imageUrl,
+      imageBase64: downloadedImage.base64,
+      imageMimeType: downloadedImage.mimeType,
+      revisedPrompt: result.revisedPrompt,
+      upstreamResponse: result.upstreamResponse,
+      errorMessage: downloadedImage.errorMessage
+    });
+
+    consola.info("[images.generate] 完成", {
+      requestId,
+      recordId: record.id.toString()
+    });
+    return createSuccessResponse<IImageGenerateData>(
+      {
+        imageUrl: result.imageUrl,
+        revisedPrompt: result.revisedPrompt
+      },
+      "图片生成成功"
+    );
   } catch (error) {
+    consola.error("[images.generate] 失败", {
+      requestId,
+      stage,
+      recordId: record?.id.toString() ?? null,
+      error: toSafeLogError(error)
+    });
+
+    if (record) {
+      await finishImageGenerationFailed(record.id, record.startedAt, error).catch(
+        (recordError) => {
+          consola.error("[images.generate] 更新失败记录失败", {
+            requestId,
+            recordId: record?.id.toString() ?? null,
+            error: toSafeLogError(recordError)
+          });
+        }
+      );
+    }
+
     if (isUnauthorizedError(error)) {
       clearNewApiAuthCookies(event);
       return createErrorResponse(401, "未登录");
@@ -42,3 +131,53 @@ export default defineEventHandler(async (event) => {
     return createUpstreamErrorResponse(error, "图片生成失败");
   }
 });
+
+/** 图片 URL 仍然可用时，base64 保存失败不阻断本次生成结果 */
+const downloadGeneratedImage = async (
+  imageUrl: string
+): Promise<{
+  base64: string | null;
+  mimeType: string | null;
+  errorMessage: string | null;
+}> => {
+  try {
+    const image = await downloadImageAsBase64(imageUrl);
+    return {
+      base64: image.base64,
+      mimeType: image.mimeType,
+      errorMessage: null
+    };
+  } catch (error) {
+    consola.error("[images.generate] 保存生成图片 base64 失败", {
+      error: toSafeLogError(error)
+    });
+    return {
+      base64: null,
+      mimeType: null,
+      errorMessage: "图片生成成功，但 base64 保存失败"
+    };
+  }
+};
+
+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;
+  };
+
+  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
+  };
+};

server/api/images/history.get.ts

@@ -0,0 +1,52 @@
+import type { IImageHistoryListData } from "#shared/types/openai";
+import {
+  clearNewApiAuthCookies,
+  getNewApiUserIdFromCookie,
+  isUnauthorizedError,
+  listImageGenerationHistory
+} from "~~/server/utils";
+
+const DEFAULT_PAGE = 1;
+const DEFAULT_PAGE_SIZE = 10;
+const MAX_PAGE_SIZE = 50;
+
+export default defineEventHandler(async (event) => {
+  try {
+    const userId = getNewApiUserIdFromCookie(event);
+    const query = getQuery(event);
+    const page = normalizePositiveInt(query.page, DEFAULT_PAGE);
+    const pageSize = Math.min(
+      normalizePositiveInt(query.size, DEFAULT_PAGE_SIZE),
+      MAX_PAGE_SIZE
+    );
+    const result = await listImageGenerationHistory({
+      userId,
+      page,
+      pageSize
+    });
+
+    return createSuccessResponse<IImageHistoryListData>(
+      result,
+      "获取生图历史成功"
+    );
+  } catch (error) {
+    if (isUnauthorizedError(error)) {
+      clearNewApiAuthCookies(event);
+      return createErrorResponse(401, "未登录");
+    }
+
+    return createUpstreamErrorResponse(error, "获取生图历史失败");
+  }
+});
+
+const normalizePositiveInt = (
+  value: unknown,
+  fallbackValue: number
+): number => {
+  const rawValue = Array.isArray(value) ? value[0] : value;
+  const numberValue = Number.parseInt(String(rawValue ?? ""), 10);
+
+  return Number.isInteger(numberValue) && numberValue > 0
+    ? numberValue
+    : fallbackValue;
+};

server/api/images/history/[id].delete.ts

@@ -0,0 +1,38 @@
+import {
+  clearNewApiAuthCookies,
+  getNewApiUserIdFromCookie,
+  isUnauthorizedError,
+  softDeleteImageGeneration
+} from "~~/server/utils";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const userId = getNewApiUserIdFromCookie(event);
+    const recordId = parseRecordId(getRouterParam(event, "id"));
+    const deleted = await softDeleteImageGeneration(userId, recordId);
+
+    if (!deleted) {
+      return createErrorResponse(404, "生图记录不存在");
+    }
+
+    return createSuccessResponse(null, "删除生图记录成功");
+  } catch (error) {
+    if (isUnauthorizedError(error)) {
+      clearNewApiAuthCookies(event);
+      return createErrorResponse(401, "未登录");
+    }
+
+    return createUpstreamErrorResponse(error, "删除生图记录失败");
+  }
+});
+
+const parseRecordId = (value: string | undefined): bigint => {
+  if (!value || !/^\d+$/.test(value)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "生图记录 ID 不正确"
+    });
+  }
+
+  return BigInt(value);
+};

server/api/images/history/[id].get.ts

@@ -0,0 +1,42 @@
+import type { IImageHistoryDetail } from "#shared/types/openai";
+import {
+  clearNewApiAuthCookies,
+  getImageGenerationDetail,
+  getNewApiUserIdFromCookie,
+  isUnauthorizedError
+} from "~~/server/utils";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const userId = getNewApiUserIdFromCookie(event);
+    const recordId = parseRecordId(getRouterParam(event, "id"));
+    const result = await getImageGenerationDetail(userId, recordId);
+
+    if (!result) {
+      return createErrorResponse(404, "生图记录不存在");
+    }
+
+    return createSuccessResponse<IImageHistoryDetail>(
+      result,
+      "获取生图详情成功"
+    );
+  } catch (error) {
+    if (isUnauthorizedError(error)) {
+      clearNewApiAuthCookies(event);
+      return createErrorResponse(401, "未登录");
+    }
+
+    return createUpstreamErrorResponse(error, "获取生图详情失败");
+  }
+});
+
+const parseRecordId = (value: string | undefined): bigint => {
+  if (!value || !/^\d+$/.test(value)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "生图记录 ID 不正确"
+    });
+  }
+
+  return BigInt(value);
+};

server/api/images/stats.get.ts

@@ -0,0 +1,15 @@
+import type { IImageGenerationStatsData } from "#shared/types/openai";
+import { getGenerationStats } from "~~/server/utils";
+
+export default defineEventHandler(async () => {
+  try {
+    const result = await getGenerationStats();
+
+    return createSuccessResponse<IImageGenerationStatsData>(
+      result,
+      "获取生图统计成功"
+    );
+  } catch (error) {
+    return createUpstreamErrorResponse(error, "获取生图统计失败");
+  }
+});

server/utils/imageAssets.ts

@@ -0,0 +1,23 @@
+export interface IDownloadedImage {
+  /** 图片 base64 原文，不包含 data URL 前缀 */
+  base64: string;
+  /** 图片 MIME 类型 */
+  mimeType: string;
+}
+
+/** 下载远程图片并转成 base64，用于生图结果归档 */
+export const downloadImageAsBase64 = async (
+  imageUrl: string
+): Promise<IDownloadedImage> => {
+  const response = await fetch(imageUrl);
+  if (!response.ok) {
+    throw new Error(`图片下载失败：${response.status}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+
+  return {
+    base64: Buffer.from(arrayBuffer).toString("base64"),
+    mimeType: response.headers.get("content-type") || "image/png"
+  };
+};

server/utils/imageGenerationRecords.ts

@@ -0,0 +1,384 @@
+import type { IUserBasicData } from "#shared/types";
+import type {
+  IImageGenerationStatsData,
+  IImageHistoryDetail,
+  IImageHistoryItem,
+  IImageHistoryListData
+} from "#shared/types/openai";
+import { consola } from "consola";
+import { ImageGenerationStatus, Prisma } from "~~/app/generated/prisma/client";
+import { prisma } from "~~/server/utils/prisma";
+
+const GLOBAL_STATS_ID = "global";
+const DEFAULT_IMAGE_MODEL = "gpt-image-2";
+const DEFAULT_IMAGE_SIZE = "1024x1024";
+
+interface IFinishImageGenerationSuccessInput {
+  /** 生成图片 URL */
+  imageUrl: string;
+  /** 生成图片 base64 原文 */
+  imageBase64: string | null;
+  /** 图片 MIME 类型 */
+  imageMimeType: string | null;
+  /** 上游返回的修订提示词 */
+  revisedPrompt?: string | null;
+  /** 完整上游响应 */
+  upstreamResponse: unknown;
+  /** 成功状态下的非阻断提示，例如 base64 保存失败 */
+  errorMessage?: string | null;
+}
+
+/** 登录或恢复登录时保存 NewAPI 用户快照 */
+export const upsertUserSnapshot = (user: IUserBasicData) => {
+  return prisma.user.upsert({
+    where: {
+      id: user.id
+    },
+    create: {
+      id: user.id,
+      username: user.username,
+      displayName: user.display_name,
+      group: user.group,
+      role: user.role,
+      status: user.status
+    },
+    update: {
+      username: user.username,
+      displayName: user.display_name,
+      group: user.group,
+      role: user.role,
+      status: user.status
+    }
+  });
+};
+
+/** 仅有 userId 时兜底创建用户记录，避免旧 cookie 用户生成时外键失败 */
+export const ensureUserRecord = (userId: number) => {
+  return prisma.user.upsert({
+    where: {
+      id: userId
+    },
+    create: {
+      id: userId
+    },
+    update: {}
+  });
+};
+
+/** 创建进行中的生图记录，并递增全局请求与进行中统计 */
+export const createRunningImageGeneration = async (
+  userId: number,
+  prompt: string
+) => {
+  await ensureUserRecord(userId);
+
+  const record = await prisma.imageGeneration.create({
+    data: {
+      userId,
+      prompt,
+      status: ImageGenerationStatus.RUNNING,
+      model: DEFAULT_IMAGE_MODEL,
+      size: DEFAULT_IMAGE_SIZE
+    }
+  });
+
+  await safeUpsertGenerationStats({
+    totalRequests: {
+      increment: 1
+    },
+    runningRequests: {
+      increment: 1
+    }
+  });
+
+  return record;
+};
+
+/** 将生图记录标记为成功，并保存 URL、base64、完整上游响应和耗时 */
+export const finishImageGenerationSuccess = async (
+  recordId: bigint,
+  startedAt: Date,
+  input: IFinishImageGenerationSuccessInput
+) => {
+  const endedAt = new Date();
+  const successData = {
+    status: ImageGenerationStatus.SUCCEEDED,
+    endedAt,
+    durationMs: getDurationMs(startedAt, endedAt),
+    imageUrl: input.imageUrl,
+    imageBase64: input.imageBase64,
+    imageMimeType: input.imageMimeType,
+    revisedPrompt: input.revisedPrompt || null,
+    upstreamResponse: input.upstreamResponse as Prisma.InputJsonValue,
+    errorMessage: input.errorMessage || null
+  };
+
+  try {
+    await prisma.imageGeneration.update({
+      where: {
+        id: recordId
+      },
+      data: successData
+    });
+  } catch (error) {
+    if (!input.imageBase64) {
+      throw error;
+    }
+
+    consola.error("[imageGenerationRecords] 保存带 base64 的成功记录失败，重试仅保存 URL", {
+      recordId: recordId.toString(),
+      message: error instanceof Error ? error.message : String(error)
+    });
+
+    await prisma.imageGeneration.update({
+      where: {
+        id: recordId
+      },
+      data: {
+        ...successData,
+        imageBase64: null,
+        errorMessage: mergeRecordMessages(
+          input.errorMessage,
+          "图片生成成功，但 base64 归档保存失败"
+        )
+      }
+    });
+  }
+
+  await safeUpsertGenerationStats({
+    successRequests: {
+      increment: 1
+    },
+    runningRequests: {
+      decrement: 1
+    },
+    totalImages: {
+      increment: 1
+    }
+  });
+};
+
+/** 将生图记录标记为失败，并保存失败原因和耗时 */
+export const finishImageGenerationFailed = async (
+  recordId: bigint,
+  startedAt: Date,
+  error: unknown
+) => {
+  const endedAt = new Date();
+
+  await prisma.imageGeneration.update({
+    where: {
+      id: recordId
+    },
+    data: {
+      status: ImageGenerationStatus.FAILED,
+      endedAt,
+      durationMs: getDurationMs(startedAt, endedAt),
+      errorMessage: getSafeErrorMessage(error)
+    }
+  });
+
+  await safeUpsertGenerationStats({
+    failedRequests: {
+      increment: 1
+    },
+    runningRequests: {
+      decrement: 1
+    }
+  });
+};
+
+/** 查询当前用户未删除的生图历史列表，不返回 base64 和完整上游响应 */
+export const listImageGenerationHistory = async ({
+  userId,
+  page,
+  pageSize
+}: {
+  userId: number;
+  page: number;
+  pageSize: number;
+}): Promise<IImageHistoryListData> => {
+  const where = {
+    userId,
+    deletedAt: null
+  };
+
+  const [total, records] = await prisma.$transaction([
+    prisma.imageGeneration.count({ where }),
+    prisma.imageGeneration.findMany({
+      where,
+      orderBy: {
+        createdAt: "desc"
+      },
+      skip: (page - 1) * pageSize,
+      take: pageSize
+    })
+  ]);
+
+  return {
+    page,
+    pageSize,
+    total,
+    items: records.map(mapImageGenerationItem)
+  };
+};
+
+/** 查询当前用户单条生图历史详情 */
+export const getImageGenerationDetail = async (
+  userId: number,
+  recordId: bigint
+): Promise<IImageHistoryDetail | null> => {
+  const record = await prisma.imageGeneration.findFirst({
+    where: {
+      id: recordId,
+      userId,
+      deletedAt: null
+    }
+  });
+
+  if (!record) return null;
+
+  return {
+    ...mapImageGenerationItem(record),
+    imageBase64: record.imageBase64,
+    imageMimeType: record.imageMimeType,
+    upstreamResponse: record.upstreamResponse
+  };
+};
+
+/** 软删除当前用户单条生图历史 */
+export const softDeleteImageGeneration = async (
+  userId: number,
+  recordId: bigint
+): Promise<boolean> => {
+  const result = await prisma.imageGeneration.updateMany({
+    where: {
+      id: recordId,
+      userId,
+      deletedAt: null
+    },
+    data: {
+      deletedAt: new Date()
+    }
+  });
+
+  return result.count > 0;
+};
+
+/** 读取全局生图统计，没有记录时返回全 0 */
+export const getGenerationStats =
+  async (): Promise<IImageGenerationStatsData> => {
+    const stats = await prisma.generationStats.findUnique({
+      where: {
+        id: GLOBAL_STATS_ID
+      }
+    });
+
+    return {
+      totalRequests: stats?.totalRequests ?? 0,
+      successRequests: stats?.successRequests ?? 0,
+      failedRequests: stats?.failedRequests ?? 0,
+      queuedRequests: stats?.queuedRequests ?? 0,
+      runningRequests: stats?.runningRequests ?? 0,
+      totalImages: stats?.totalImages ?? 0
+    };
+  };
+
+/** 统一创建或更新全局统计行 */
+const upsertGenerationStats = (update: Prisma.GenerationStatsUpdateInput) => {
+  return prisma.generationStats.upsert({
+    where: {
+      id: GLOBAL_STATS_ID
+    },
+    create: {
+      id: GLOBAL_STATS_ID,
+      ...buildStatsCreateInput(update)
+    },
+    update
+  });
+};
+
+const safeUpsertGenerationStats = async (
+  update: Prisma.GenerationStatsUpdateInput
+) => {
+  try {
+    await upsertGenerationStats(update);
+  } catch (error) {
+    consola.error("[imageGenerationRecords] 更新生图统计失败", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+
+const buildStatsCreateInput = (update: Prisma.GenerationStatsUpdateInput) => {
+  return {
+    totalRequests: getIncrementValue(update.totalRequests),
+    successRequests: getIncrementValue(update.successRequests),
+    failedRequests: getIncrementValue(update.failedRequests),
+    queuedRequests: getIncrementValue(update.queuedRequests),
+    runningRequests: getIncrementValue(update.runningRequests),
+    totalImages: getIncrementValue(update.totalImages)
+  };
+};
+
+const getIncrementValue = (value: unknown): number => {
+  if (
+    value &&
+    typeof value === "object" &&
+    "increment" in value &&
+    typeof value.increment === "number"
+  ) {
+    return value.increment;
+  }
+
+  return 0;
+};
+
+const mapImageGenerationItem = (record: {
+  id: bigint;
+  userId: number;
+  prompt: string;
+  status: ImageGenerationStatus;
+  model: string;
+  size: string;
+  startedAt: Date;
+  endedAt: Date | null;
+  durationMs: number | null;
+  imageUrl: string | null;
+  revisedPrompt: string | null;
+  errorMessage: string | null;
+  createdAt: Date;
+}): IImageHistoryItem => {
+  return {
+    id: record.id.toString(),
+    userId: record.userId,
+    prompt: record.prompt,
+    status: record.status,
+    model: record.model,
+    size: record.size,
+    startedAt: record.startedAt.toISOString(),
+    endedAt: record.endedAt?.toISOString() ?? null,
+    durationMs: record.durationMs,
+    imageUrl: record.imageUrl,
+    revisedPrompt: record.revisedPrompt,
+    errorMessage: record.errorMessage,
+    createdAt: record.createdAt.toISOString()
+  };
+};
+
+const getDurationMs = (startedAt: Date, endedAt: Date) => {
+  return Math.max(0, endedAt.getTime() - startedAt.getTime());
+};
+
+const mergeRecordMessages = (
+  currentMessage: string | null | undefined,
+  nextMessage: string
+) => {
+  return currentMessage ? `${currentMessage}; ${nextMessage}` : nextMessage;
+};
+
+const getSafeErrorMessage = (error: unknown): string => {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return "图片生成失败";
+};

server/utils/index.ts

@@ -1,5 +1,8 @@
 export * from "./createApiResponse";
 export * from "./fetch";
+export * from "./imageAssets";
+export * from "./imageGenerationRecords";
 export * from "./newApiAuthCookies";
 export * from "./newApiTokens";
 export * from "./openai";
+export * from "./prisma";

server/utils/newApiAuthCookies.ts

@@ -1,5 +1,5 @@
 import type { H3Event } from "h3";
-import { deleteCookie, setCookie } from "h3";
+import { createError, deleteCookie, getCookie, setCookie } from "h3";
 
 /** 上游没有声明 session 过期时间时，本地登录态默认保留 3 天 */
 const DEFAULT_AUTH_COOKIE_MAX_AGE = 60 * 60 * 24 * 3;
@@ -100,6 +100,23 @@ export const clearNewApiAuthCookies = (event: H3Event) => {
   deleteCookie(event, NEWAPI_USER_ID_COOKIE, options);
 };
 
+/** 从本项目 httpOnly cookie 中读取 NewAPI 用户 ID，缺失或非法时统一视为未登录 */
+export const getNewApiUserIdFromCookie = (event: H3Event): number => {
+  const userId = Number.parseInt(
+    getCookie(event, NEWAPI_USER_ID_COOKIE) ?? "",
+    10
+  );
+
+  if (!Number.isInteger(userId) || userId <= 0) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "未登录"
+    });
+  }
+
+  return userId;
+};
+
 /** 统一生成本站认证 cookie 选项，保证安全属性在两个 cookie 上一致 */
 const buildAuthCookieOptions = (meta?: INewApiCookieMeta): CookieOptions => {
   const options: CookieOptions = {

server/utils/openai.ts

@@ -16,6 +16,13 @@ interface IImageGenerationResponse {
     /** 生成图片地址 */
     url?: string;
   }>;
+  /** 上游 token 用量 */
+  usage?: unknown;
+}
+
+export interface IAskImageResult extends IImageGenerateData {
+  /** 完整上游生图接口返回结果，仅服务端内部保存 */
+  upstreamResponse: IImageGenerationResponse;
 }
 
 /** 通用 AI 调用函数（支持文本 / 图文 / 多模态） */
@@ -107,7 +114,7 @@ export const askImg = async ({
 }: {
   apiKey: string;
   prompt: string;
-}): Promise<IImageGenerateData> => {
+}): Promise<IAskImageResult> => {
   const result = await $fetch<IImageGenerationResponse>(IMAGE_GENERATION_URL, {
     method: "POST",
     headers: {
@@ -128,7 +135,8 @@ export const askImg = async ({
 
   return {
     imageUrl: image.url,
-    revisedPrompt: image.revised_prompt
+    revisedPrompt: image.revised_prompt,
+    upstreamResponse: result
   };
 };
 

server/utils/prisma.ts

@@ -0,0 +1,76 @@
+import { PrismaMariaDb } from "@prisma/adapter-mariadb";
+import { PrismaClient } from "~~/app/generated/prisma/client";
+
+const globalForPrisma = globalThis as unknown as {
+  prisma?: PrismaClient;
+  prismaLogged?: boolean;
+};
+
+const databaseUrl = process.env.DATABASE_URL;
+
+if (!databaseUrl) {
+  throw new Error("DATABASE_URL is required to initialize PrismaClient");
+}
+
+type MariaDbPoolConfig = Exclude<ConstructorParameters<typeof PrismaMariaDb>[0], string>;
+
+function getNumberParam(url: URL, name: string, fallback: number) {
+  const value = url.searchParams.get(name);
+  if (!value) {
+    return fallback;
+  }
+
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function createMariaDbConfig(urlString: string): MariaDbPoolConfig {
+  const url = new URL(urlString);
+  const database = decodeURIComponent(url.pathname.replace(/^\//, ""));
+
+  if (!url.hostname || !url.username || !database) {
+    throw new Error("DATABASE_URL must include host, user and database");
+  }
+
+  const port = url.port ? Number(url.port) : 3306;
+
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error("DATABASE_URL port is invalid");
+  }
+
+  return {
+    host: url.hostname,
+    port,
+    user: decodeURIComponent(url.username),
+    password: decodeURIComponent(url.password),
+    database,
+    connectionLimit: getNumberParam(url, "connection_limit", 5),
+    acquireTimeout: getNumberParam(url, "pool_timeout", 30) * 1000,
+    connectTimeout: getNumberParam(url, "connect_timeout", 10) * 1000,
+  };
+}
+
+const mariaDbConfig = createMariaDbConfig(databaseUrl);
+const adapter = new PrismaMariaDb(mariaDbConfig, { database: mariaDbConfig.database });
+
+if (!globalForPrisma.prismaLogged) {
+  console.info("[prisma] initializing MariaDB pool", {
+    host: mariaDbConfig.host,
+    port: mariaDbConfig.port,
+    database: mariaDbConfig.database,
+    connectionLimit: mariaDbConfig.connectionLimit,
+  });
+  globalForPrisma.prismaLogged = true;
+}
+
+/** Reuse PrismaClient during dev hot reloads so Nuxt does not create duplicate pools. */
+export const prisma =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    adapter,
+    log: ["warn", "error"],
+  });
+
+if (process.env.NODE_ENV !== "production") {
+  globalForPrisma.prisma = prisma;
+}