feat: 新增数据库

This commit is contained in:
2026-04-25 21:52:18 +08:00
parent 223845b0ed
commit abd1b03529
23 changed files with 1890 additions and 97 deletions
+23
View File
@@ -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"
};
};
+384
View File
@@ -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 "图片生成失败";
};
+3
View File
@@ -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";
+18 -1
View File
@@ -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 = {
+10 -2
View File
@@ -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
};
};
+76
View File
@@ -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;
}