gongxiangp2/lib/upload-sessions.ts
chenpei 4dba93c4e5 feat: 完成任务-详情素材迁移到新逻辑
- 迁移57个老素材到新逻辑(本地zip + S3预览图)
- 优化文件命名:SPU_作者_店铺_类型.zip
- PSD文件单独存储,不打包进all.zip
- 修复下载接口,优先使用本地zip文件
- 修复预览图重复问题
- 添加迁移脚本和验证脚本
- 更新文档和迁移计划

迁移统计:
- 总素材数:77个
- 成功迁移:57个
- 新逻辑上传:18个
- 空记录:2个
2026-01-21 10:16:28 +08:00

257 lines
7.2 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* 上传会话存储管理
*
* 🔄 支持环境变量切换:
* - USE_REDIS=true → 使用Redis(生产环境推荐)
* - USE_REDIS=false 或未设置 → 使用内存Map(开发/测试环境)
*
* 📋 内存Map的局限性:
* 1. 数据不持久化 - 服务器/容器重启后数据丢失
* 2. 不支持多实例 - 多个容器实例无法共享会话数据
* 3. 内存管理 - 需要手动清理过期数据
* 4. 无法跨服务 - 不同服务无法共享数据
*
* ✅ Redis的优势:
* 1. 数据持久化 - 服务器重启后数据保留
* 2. 支持多实例 - 多个容器实例可以共享数据
* 3. 自动过期 - 支持TTL,无需手动清理
* 4. 跨服务共享 - 不同服务可以共享数据
*
* 📚 详细说明请查看:docs/upload-sessions-redis-explanation.md
*/
export interface UploadSession {
fileName: string
fileSize: number
totalChunks: number
chunks: Map<number, string> // chunkIndex -> chunkFilePath
createdAt: number
userId: string
}
// 检查是否使用Redis
const USE_REDIS = process.env.USE_REDIS === 'true'
// 动态导入Redis实现(如果启用)
let redisModule: typeof import('./upload-sessions-redis') | null = null
if (USE_REDIS) {
try {
// 动态导入,避免在未安装ioredis时出错
redisModule = require('./upload-sessions-redis')
console.log('[UploadSessions] 使用Redis存储(生产环境)')
} catch (error) {
console.warn('[UploadSessions] Redis模块加载失败,降级到内存Map:', error)
console.warn('[UploadSessions] 请确保已安装ioredis: npm install ioredis')
}
} else {
console.log('[UploadSessions] 使用内存Map存储(开发/测试环境)')
}
// 内存存储(单实例部署可以使用)
const memorySessions = new Map<string, UploadSession>()
function setMemorySession(uploadId: string, session: UploadSession) {
memorySessions.set(uploadId, session)
}
function deleteMemorySession(uploadId: string) {
memorySessions.delete(uploadId)
}
function getMemorySession(uploadId: string): UploadSession | null {
return memorySessions.get(uploadId) || null
}
async function withRedisFallback<T>(
actionName: string,
redisAction: () => Promise<T>,
memoryFallback: () => Promise<T> | T
): Promise<T> {
if (USE_REDIS && redisModule) {
try {
return await redisAction()
} catch (error) {
console.error(`[UploadSessions] Redis ${actionName} failed, fallback to memory:`, error)
return await memoryFallback()
}
}
return await memoryFallback()
}
// 清理过期会话(8小时)- 仅内存Map需要
if (!USE_REDIS || !redisModule) {
setInterval(() => {
const now = Date.now()
const expireTime = 8 * 60 * 60 * 1000 // 8小时
const keysToDelete: string[] = []
memorySessions.forEach((session, uploadId) => {
if (now - session.createdAt > expireTime) {
keysToDelete.push(uploadId)
}
})
keysToDelete.forEach(key => {
memorySessions.delete(key)
console.log(`[UploadSessions] 清理过期会话: ${key}`)
})
if (keysToDelete.length > 0) {
console.log(`[UploadSessions] 已清理 ${keysToDelete.length} 个过期会话`)
}
}, 60 * 60 * 1000) // 每小时清理一次
}
/**
* 保存上传会话
*/
export async function saveUploadSession(
uploadId: string,
session: UploadSession
): Promise<void> {
setMemorySession(uploadId, session)
await withRedisFallback(
'saveUploadSession',
() => redisModule!.saveUploadSession(uploadId, session),
async () => {}
)
}
/**
* 获取上传会话
*/
export async function getUploadSession(
uploadId: string
): Promise<UploadSession | null> {
return withRedisFallback(
'getUploadSession',
async () => {
const session = await redisModule!.getUploadSession(uploadId)
if (session) {
setMemorySession(uploadId, session)
}
return session
},
async () => getMemorySession(uploadId)
)
}
/**
* 获取已上传的完整文件路径(从chunk临时目录)
* 返回组装后的完整文件路径
*/
export async function getUploadedFile(uploadId: string): Promise<string | null> {
const session = await getUploadSession(uploadId);
if (!session) {
return null;
}
const path = await import('path');
const { readdir, readFile, writeFile, mkdir, access } = await import('fs/promises');
// Chunk文件所在目录
const tempDir = path.join(process.env.UPLOAD_DIR || './uploads', 'temp', uploadId);
// 输出目录和路径
const outputDir = path.join(process.env.UPLOAD_DIR || './uploads', 'assembled');
const outputPath = path.join(outputDir, `${uploadId}-${session.fileName}`);
try {
// 先检查文件是否已经存在(避免重复组装)
try {
await access(outputPath);
console.log(`[Upload Session] File already exists, skip assembly: ${outputPath}`);
return outputPath;
} catch (e) {
// 文件不存在,需要组装
}
// 读取所有chunk文件
const files = await readdir(tempDir);
const chunkFiles = files
.filter(f => f.startsWith('chunk-'))
.sort((a, b) => {
const indexA = parseInt(a.replace('chunk-', ''));
const indexB = parseInt(b.replace('chunk-', ''));
return indexA - indexB;
});
if (chunkFiles.length === 0) {
return null;
}
// 创建输出目录
await mkdir(outputDir, { recursive: true });
// 按顺序读取并写入所有chunk
const chunks: Buffer[] = [];
for (const chunkFile of chunkFiles) {
const chunkPath = path.join(tempDir, chunkFile);
const chunkBuffer = await readFile(chunkPath);
chunks.push(chunkBuffer);
}
// 合并所有chunk并写入文件
const completeBuffer = Buffer.concat(chunks);
await writeFile(outputPath, completeBuffer);
console.log(`[Upload Session] Assembled file: ${outputPath} (${completeBuffer.length} bytes)`);
return outputPath;
} catch (error) {
console.error(`[Upload Session] Failed to get uploaded file for ${uploadId}:`, error);
return null;
}
}
/**
* 删除上传会话
*/
export async function deleteUploadSession(uploadId: string): Promise<void> {
deleteMemorySession(uploadId)
await withRedisFallback(
'deleteUploadSession',
() => redisModule!.deleteUploadSession(uploadId),
async () => {}
)
}
/**
* 检查会话是否存在
*/
export async function hasUploadSession(uploadId: string): Promise<boolean> {
return withRedisFallback(
'hasUploadSession',
() => redisModule!.hasUploadSession(uploadId),
async () => memorySessions.has(uploadId)
)
}
/**
* 更新块信息
*/
export async function updateChunk(
uploadId: string,
chunkIndex: number,
chunkPath: string
): Promise<void> {
let session = getMemorySession(uploadId)
if (!session) {
session = await getUploadSession(uploadId)
}
if (!session) {
throw new Error(`上传会话不存在: ${uploadId}`)
}
session.chunks.set(chunkIndex, chunkPath)
setMemorySession(uploadId, session)
await withRedisFallback(
'updateChunk',
() => redisModule!.updateChunk(uploadId, chunkIndex, chunkPath),
async () => {}
)
}
// 导出内存Map(用于向后兼容,但不推荐直接使用)
export const uploadSessions = memorySessions