feat: logo et favicon, confirmation modale, fil d'ariane, e-mails sombres (#4)
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:
Gitea Actions
2026-10-16 11:08:47 +00:00
committed by Esiah
co-authored by Esiah
parent 25b6e0669a
commit 9dd1ad72e0
105 changed files with 2638 additions and 592 deletions
+169
View File
@@ -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;
}
};