feat: logo et favicon, confirmation modale, fil d'ariane, e-mails sombres (#4)
CD — Déploiement / deploy (push) Failing after 25s
CD — Déploiement / deploy (push) Failing after 25s
- logo embarque dans les e-mails (CID) et gabarit repense en mode sombre - favicon multi-tailles + icone PNG, logo a gauche du titre (app et auth) - modale de confirmation animee a la place de window.confirm - bouton retour et fil d'ariane dans l'explorateur --------- Co-authored-by: xEsiah <[email protected]> Reviewed-on: #4 Reviewed-by: Esiah <[email protected]> Co-authored-by: Gitea Actions <-[email protected]>
This commit was merged in pull request #4.
This commit is contained in:
@@ -0,0 +1,169 @@
|
||||
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<StoredLocation> => {
|
||||
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<Uint8Array>,
|
||||
declared: number,
|
||||
maxBytes: number,
|
||||
): Promise<WriteResult> => {
|
||||
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<typeof Readable.fromWeb>[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<void> => {
|
||||
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<void> => {
|
||||
await rename(temporary, destination);
|
||||
};
|
||||
|
||||
export const discard = async (...paths: string[]): Promise<void> => {
|
||||
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<boolean> => {
|
||||
try {
|
||||
const info = await stat(absolute);
|
||||
return info.isFile();
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
export const openForDownload = (absolute: string) => createReadStream(absolute);
|
||||
|
||||
/**
|
||||
* 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<DiskUsage | null> => {
|
||||
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;
|
||||
}
|
||||
};
|
||||
Reference in New Issue
Block a user