108 lines
3.7 KiB
TypeScript
108 lines
3.7 KiB
TypeScript
import { db } from "@/config/db";
|
|
import { getCurrentUser } from "@/handlers/serverUtils/user.utils";
|
|
import {
|
|
getCompressionOutputFileName,
|
|
getCompressionOutputPath,
|
|
getCompressionDirectory,
|
|
readCompressionJob,
|
|
} from "@/helpers/compression.server";
|
|
import { assets, exif } from "@/schema";
|
|
import { and, eq, inArray } from "drizzle-orm";
|
|
import { readdir, stat } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import type { NextApiRequest, NextApiResponse } from "next";
|
|
|
|
const COMPRESSION_ROOT = "/app/data/compression";
|
|
|
|
export default async function handler(req: NextApiRequest, res: NextApiResponse) {
|
|
const currentUser = await getCurrentUser(req);
|
|
if (!currentUser) return res.status(401).json({ message: "Unauthorized" });
|
|
if (req.method !== "GET") return res.status(405).json({ message: "Method not allowed" });
|
|
|
|
let assetIds: string[] = [];
|
|
try {
|
|
const entries = await readdir(COMPRESSION_ROOT, { withFileTypes: true });
|
|
assetIds = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
|
|
} catch (error: any) {
|
|
if (error?.code === "ENOENT") return res.status(200).json([]);
|
|
throw error;
|
|
}
|
|
|
|
if (assetIds.length === 0) return res.status(200).json([]);
|
|
|
|
const results: any[] = [];
|
|
const legacyAssetIds: string[] = [];
|
|
|
|
for (const assetId of assetIds) {
|
|
const job = await readCompressionJob(assetId);
|
|
if (!job) {
|
|
legacyAssetIds.push(assetId);
|
|
continue;
|
|
}
|
|
if (job.ownerId !== currentUser.id) continue;
|
|
|
|
try {
|
|
const outputPath = path.join(getCompressionDirectory(job.sourceAssetId), job.outputFileName);
|
|
const outputStat = await stat(outputPath);
|
|
if (!outputStat.isFile()) continue;
|
|
|
|
results.push({
|
|
assetId: job.sourceAssetId,
|
|
originalFileName: job.originalFileName,
|
|
outputFileName: job.outputFileName,
|
|
localDateTime: job.localDateTime,
|
|
originalSize: job.originalSize,
|
|
compressedSize: outputStat.size,
|
|
compressedAt: job.compressedAt,
|
|
resultUrl: `/api/assets/compression/result/${job.sourceAssetId}`,
|
|
status: job.status,
|
|
replacementAssetId: job.replacementAssetId,
|
|
replacementStartedAt: job.replacementStartedAt,
|
|
replacedAt: job.replacedAt,
|
|
});
|
|
} catch {
|
|
// Ignore stale job directories whose compressed output is gone.
|
|
}
|
|
}
|
|
|
|
// Backwards compatibility for compressed files created before job.json existed.
|
|
if (legacyAssetIds.length > 0) {
|
|
const rows = await db
|
|
.select({
|
|
id: assets.id,
|
|
originalFileName: assets.originalFileName,
|
|
localDateTime: assets.localDateTime,
|
|
originalSize: exif.fileSizeInByte,
|
|
})
|
|
.from(assets)
|
|
.leftJoin(exif, eq(assets.id, exif.assetId))
|
|
.where(and(eq(assets.ownerId, currentUser.id), inArray(assets.id, legacyAssetIds)));
|
|
|
|
for (const asset of rows) {
|
|
try {
|
|
const outputPath = getCompressionOutputPath(asset.id, asset.originalFileName);
|
|
const outputStat = await stat(outputPath);
|
|
if (!outputStat.isFile()) continue;
|
|
|
|
results.push({
|
|
assetId: asset.id,
|
|
originalFileName: asset.originalFileName,
|
|
outputFileName: getCompressionOutputFileName(asset.id, asset.originalFileName),
|
|
localDateTime: asset.localDateTime,
|
|
originalSize: Number(asset.originalSize ?? 0),
|
|
compressedSize: outputStat.size,
|
|
compressedAt: outputStat.mtime.toISOString(),
|
|
resultUrl: `/api/assets/compression/result/${asset.id}`,
|
|
status: "compressed",
|
|
});
|
|
} catch {
|
|
// Ignore incomplete legacy result directories.
|
|
}
|
|
}
|
|
}
|
|
|
|
return res.status(200).json(
|
|
results.sort((a, b) => b.compressedAt.localeCompare(a.compressedAt))
|
|
);
|
|
}
|