import { createHash, randomUUID } from "node:crypto"; import { createReadStream, createWriteStream } from "node:fs"; import { mkdir, rename, rm, stat, statfs } from "node:fs/promises"; import path from "node:path"; import { Readable, Transform } from "node:stream"; import { pipeline } from "node:stream/promises"; import { AppError, type Db } from "./lib/index.js"; /** * Chemin physique : ${MEDIA_DIR}/${slug emplacement}/${uuid}. * * Le nom affiche n'apparait jamais dans le chemin. Outre qu'il evite toute * escape via "../", il empeche deux depots homonymes de se marcher dessus et * rend l'arborescence disque ininteressante a parcourir pour un tiers. */ const SLUG = /^[a-z0-9][a-z0-9-]{0,99}$/; const EXTENSION = /^[.][a-z0-9]{1,10}$/i; export interface StoredLocation { id: number; slug: string; } /** Extension conservee pour la lisibilite sur disque, jamais pour le routage. */ const extensionOf = (name: string): string => { const ext = path.posix.extname(name); return EXTENSION.test(ext) ? ext.toLowerCase() : ""; }; export const relativePathFor = (slug: string, uuid: string, name: string): string => path.posix.join(slug, uuid + extensionOf(name)); const resolveInside = (mediaDir: string, relative: string): string => { const base = path.resolve(mediaDir); const target = path.resolve(base, relative); if (target !== base && !target.startsWith(base + path.sep)) { throw AppError.badRequest("Chemin de stockage invalide."); } return target; }; export const absolutePath = (mediaDir: string, relative: string): string => resolveInside(mediaDir, relative); /** * Choix de l'emplacement : celui qui offre le plus de marge. Les comptes sont * eux-memes plafonnes, donc cette valeur sert a ne pas remplir un support * tandis qu'un autre reste vide. */ export const chooseLocation = async (db: Db, bytes: bigint): Promise => { const rows = await db.query<{ id: number; slug: string; remaining: number | null }>( `SELECT id, slug, CASE WHEN quota_bytes IS NULL THEN NULL ELSE quota_bytes - used_bytes END AS remaining FROM storage_locations WHERE is_active = 1 AND deleted_at IS NULL ORDER BY (remaining IS NULL) DESC, remaining DESC, id LIMIT 1`, ); const row = rows[0]; if (!row || !SLUG.test(row.slug)) { throw AppError.serviceUnavailable("Aucun emplacement de stockage disponible."); } if (row.remaining !== null && BigInt(row.remaining) < bytes) { throw AppError.payloadTooLarge("L'espace disponible sur le support est insuffisant."); } return { id: row.id, slug: row.slug }; }; interface WriteResult { size: number; checksum: string; } /** * Ecrit le corps de la requete sur disque en une seule passe : hachage, * comptage et gravure avancent ensemble, sans jamais faire tenir le fichier * en memoire. La lecture est interrompue des que la borne est depassee, donc * un envoi enorme ne remplit pas d'abord le disque pour echouer ensuite. */ export const writeBody = async ( destination: string, body: ReadableStream, declared: number, maxBytes: number, ): Promise => { const hash = createHash("sha256"); let received = 0; const meter = new Transform({ transform(chunk: Buffer, _encoding, callback) { received += chunk.length; if (received > maxBytes) { callback(AppError.payloadTooLarge(`Fichier trop volumineux (maximum ${maxBytes} octets).`)); return; } hash.update(chunk); callback(null, chunk); }, }); const source = Readable.fromWeb(body as Parameters[0]); await pipeline(source, meter, createWriteStream(destination, { flags: "wx" })); // Taille declaree et taille recue doivent concorder : sans quoi le quota // aurait ete reserve sur une valeur que le disque n'a pas confirmee. if (received !== declared) { throw AppError.badRequest( `Longueur incoherente : ${declared} octets annonces, ${received} recus.`, ); } return { size: received, checksum: hash.digest("hex") }; }; export const ensureDir = async (directory: string): Promise => { await mkdir(directory, { recursive: true }); }; /** Publie un fichier temporaire : meme systeme de fichiers, donc operation atomique. */ export const publish = async (temporary: string, destination: string): Promise => { await rename(temporary, destination); }; export const discard = async (...paths: string[]): Promise => { await Promise.all(paths.map((entry) => rm(entry, { force: true }).catch(() => undefined))); }; export const temporaryPath = (mediaDir: string, slug: string): string => path.join(path.resolve(mediaDir), slug, `.upload-${randomUUID()}`); export const fileExists = async (absolute: string): Promise => { try { const info = await stat(absolute); return info.isFile(); } catch { return false; } }; /** * Ouvre un fichier en lecture. `range` restreint le flux a un intervalle * d'octets inclusif, ce qui permet de repondre a une requete HTTP `Range` * (deplacement dans une video ou un morceau audio) sans lire tout le fichier. */ export const openForDownload = (absolute: string, range?: { start: number; end: number }) => createReadStream(absolute, range); /** * Occupation reelle du support qui porte `target`. Sert a refuser un quota * plus grand que le disque et a prevenir un eclatement d'ENOSPC : l'espace * logique (used_bytes) peut etre disponible alors que le disque est plein. */ export interface DiskUsage { total_bytes: number; /** Blocs libres, blocs reserves du systeme de fichiers inclus. */ free_bytes: number; /** Blocs utilisables par le processus (hors reserve root). */ available_bytes: number; } export const diskUsage = async (target: string): Promise => { try { const info = await statfs(target, { bigint: true }); return { total_bytes: Number(info.blocks * info.bsize), free_bytes: Number(info.bfree * info.bsize), available_bytes: Number(info.bavail * info.bsize), }; } catch { // Support absent ou non monté : l'appelant decide du repli. return null; } };