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,223 @@
|
||||
import { createHash, randomBytes, randomUUID, scrypt as scryptCallback, timingSafeEqual } from "node:crypto";
|
||||
import { promisify } from "node:util";
|
||||
import type { Context, Next } from "hono";
|
||||
import { getCookie, setCookie, deleteCookie } from "hono/cookie";
|
||||
import type { Db } from "./db.js";
|
||||
import { AppError } from "./errors.js";
|
||||
|
||||
const scrypt = promisify(scryptCallback) as (
|
||||
password: string | Buffer,
|
||||
salt: Buffer,
|
||||
keylen: number,
|
||||
options: { N: number; r: number; p: number; maxmem?: number },
|
||||
) => Promise<Buffer>;
|
||||
|
||||
/**
|
||||
* scrypt du module natif, pas une dependance externe. Une lib native a compiler
|
||||
* est la facon la plus rapide de casser un build sur une machine cible : argon2
|
||||
* ou bcrypt produisent un binaire qui n'est pas portable sans outilchain.
|
||||
* node:crypto est deja la, et scrypt est un KDF defini par RFC 7914.
|
||||
*/
|
||||
const SCRYPT = { N: 16384, r: 8, p: 1, keylen: 64, maxmem: 32 * 1024 * 1024 };
|
||||
|
||||
export const hashPassword = async (password: string): Promise<string> => {
|
||||
if (Buffer.byteLength(password) < 8) {
|
||||
throw AppError.badRequest("Le mot de passe doit contenir au moins 8 caracteres.");
|
||||
}
|
||||
const salt = randomBytes(16);
|
||||
const derived = await scrypt(password, salt, SCRYPT.keylen, SCRYPT);
|
||||
return `scrypt$${SCRYPT.N}$${SCRYPT.r}$${SCRYPT.p}$${salt.toString("base64")}$${derived.toString("base64")}`;
|
||||
};
|
||||
|
||||
export const verifyPassword = async (password: string, stored: string): Promise<boolean> => {
|
||||
const parts = stored.split("$");
|
||||
if (parts.length !== 6 || parts[0] !== "scrypt") return false;
|
||||
const [, n, r, p, saltB64, hashB64] = parts;
|
||||
const salt = Buffer.from(saltB64 ?? "", "base64");
|
||||
const expected = Buffer.from(hashB64 ?? "", "base64");
|
||||
if (expected.length === 0) return false;
|
||||
|
||||
const derived = await scrypt(password, salt, expected.length, {
|
||||
N: Number(n),
|
||||
r: Number(r),
|
||||
p: Number(p),
|
||||
maxmem: SCRYPT.maxmem,
|
||||
});
|
||||
return derived.length === expected.length && timingSafeEqual(derived, expected);
|
||||
};
|
||||
|
||||
export const sha256 = (value: string): string => createHash("sha256").update(value).digest("hex");
|
||||
|
||||
/**
|
||||
* Portrait de l'utilisateur porte par la session.
|
||||
*
|
||||
* Les budgets de stockage n'y figurent pas : une valeur figee dans un cookie
|
||||
* serait fausse des la premiere ecriture. Chaque route qui en a besoin relit
|
||||
* les colonnes en base au moment de l'usage.
|
||||
*/
|
||||
export interface SessionUser {
|
||||
id: string;
|
||||
email: string;
|
||||
first_name: string;
|
||||
last_name: string;
|
||||
role_slug: string;
|
||||
role_name: string;
|
||||
is_active: number;
|
||||
must_change_password: number;
|
||||
}
|
||||
|
||||
export interface SessionMeta {
|
||||
ipAddress?: string | null | undefined;
|
||||
userAgent?: string | null | undefined;
|
||||
}
|
||||
|
||||
export const SESSION_COOKIE = "cohaise_session";
|
||||
|
||||
/**
|
||||
* Le jeton brut part dans le cookie, son empreinte SHA-256 dans la base.
|
||||
* Une copie de la base ne donne donc aucune session ouvrable : il faudrait
|
||||
* en plus la table des cookies, qui n'existe pas.
|
||||
*/
|
||||
export const createSession = async (
|
||||
db: Db,
|
||||
userId: string,
|
||||
meta: SessionMeta,
|
||||
ttlHours: number,
|
||||
): Promise<{ token: string; expiresAt: Date }> => {
|
||||
const token = randomBytes(32).toString("base64url");
|
||||
const expiresAt = new Date(Date.now() + ttlHours * 3600_000);
|
||||
|
||||
await db.exec(
|
||||
`INSERT INTO user_sessions (id, user_id, token_hash, ip_address, user_agent, expires_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?)`,
|
||||
[
|
||||
randomUUID(),
|
||||
userId,
|
||||
sha256(token),
|
||||
meta.ipAddress ?? null,
|
||||
meta.userAgent?.slice(0, 255) ?? null,
|
||||
expiresAt,
|
||||
],
|
||||
);
|
||||
return { token, expiresAt };
|
||||
};
|
||||
|
||||
export const resolveSession = async (db: Db, token: string): Promise<SessionUser | null> => {
|
||||
const row = await db.one<SessionUser & { last_seen_at: string }>(
|
||||
`SELECT u.id, u.email, u.first_name, u.last_name,
|
||||
r.slug AS role_slug, r.name AS role_name,
|
||||
u.is_active, u.must_change_password,
|
||||
s.last_seen_at
|
||||
FROM user_sessions s
|
||||
JOIN users u ON u.id = s.user_id
|
||||
JOIN roles r ON r.id = u.role_id
|
||||
WHERE s.token_hash = ?
|
||||
AND s.revoked_at IS NULL
|
||||
AND s.expires_at > UTC_TIMESTAMP()
|
||||
AND u.deleted_at IS NULL
|
||||
AND u.is_active = 1`,
|
||||
[sha256(token)],
|
||||
);
|
||||
if (!row) return null;
|
||||
// Etat vu, avec un decalage de 60 s pour ne pas ecrire a chaque requete.
|
||||
await db.exec(
|
||||
"UPDATE user_sessions SET last_seen_at = UTC_TIMESTAMP() WHERE token_hash = ? AND last_seen_at < UTC_TIMESTAMP(3) - INTERVAL 60 SECOND",
|
||||
[sha256(token)],
|
||||
);
|
||||
return row;
|
||||
};
|
||||
|
||||
export const revokeSession = async (db: Db, token: string): Promise<void> => {
|
||||
await db.exec("UPDATE user_sessions SET revoked_at = UTC_TIMESTAMP() WHERE token_hash = ?", [
|
||||
sha256(token),
|
||||
]);
|
||||
};
|
||||
|
||||
export const purgeExpiredSessions = async (db: Db): Promise<number> => {
|
||||
const result = await db.exec("DELETE FROM user_sessions WHERE expires_at < UTC_TIMESTAMP()");
|
||||
return result.affectedRows;
|
||||
};
|
||||
|
||||
/**
|
||||
* Secure depend du schema reel de la requete, pas d'une origine configuree.
|
||||
*
|
||||
* Deriver Secure de PUBLIC_ORIGIN rendait tout test local impossible : le
|
||||
* navigateur rejette en HTTP un cookie marque Secure, donc la connexion
|
||||
* echouait sans message exploitable. A l'inverse, un cookie non Secure servi en
|
||||
* HTTPS laisserait le jeton circuler en clair.
|
||||
*
|
||||
* X-Forwarded-Proto n'est pris en compte que si le service fait confiance a son
|
||||
* proxy ; sinon la connexion parle d'elle-meme.
|
||||
*/
|
||||
export const isHttpsRequest = (context: Context, trustProxy: boolean): boolean => {
|
||||
if (trustProxy) {
|
||||
const forwarded = context.req.header("x-forwarded-proto");
|
||||
if (forwarded) return forwarded.split(",")[0]?.trim() === "https";
|
||||
}
|
||||
return context.req.raw.url.startsWith("https:");
|
||||
};
|
||||
|
||||
export const setSessionCookie = (
|
||||
context: Context,
|
||||
token: string,
|
||||
expiresAt: Date,
|
||||
secure: boolean,
|
||||
): void => {
|
||||
setCookie(context, SESSION_COOKIE, token, {
|
||||
httpOnly: true,
|
||||
sameSite: "Lax",
|
||||
secure,
|
||||
path: "/",
|
||||
expires: expiresAt,
|
||||
});
|
||||
};
|
||||
|
||||
export const clearSessionCookie = (context: Context): void => {
|
||||
deleteCookie(context, SESSION_COOKIE, { path: "/" });
|
||||
};
|
||||
|
||||
export interface AuthState {
|
||||
user: SessionUser;
|
||||
token: string;
|
||||
}
|
||||
|
||||
/** Lit le cookie et attache l'utilisateur, sans exiger qu'il existe. */
|
||||
export const attachUser =
|
||||
(db: Db) =>
|
||||
async (context: Context, next: Next): Promise<void> => {
|
||||
const token = getCookie(context, SESSION_COOKIE);
|
||||
if (token) {
|
||||
const user = await resolveSession(db, token);
|
||||
if (user) {
|
||||
context.set("user", user);
|
||||
context.set("token", token);
|
||||
} else {
|
||||
clearSessionCookie(context);
|
||||
}
|
||||
}
|
||||
await next();
|
||||
};
|
||||
|
||||
export const requireAuth = async (context: Context, next: Next): Promise<void> => {
|
||||
const user = context.get("user") as SessionUser | undefined;
|
||||
if (!user) throw AppError.unauthorized();
|
||||
await next();
|
||||
};
|
||||
|
||||
/** Le role est impose en base, jamais en entete, donc ni cacheable ni falsifiable. */
|
||||
export const requireRole =
|
||||
(...slugs: string[]) =>
|
||||
async (context: Context, next: Next): Promise<void> => {
|
||||
const user = context.get("user") as SessionUser | undefined;
|
||||
if (!user) throw AppError.unauthorized();
|
||||
if (!slugs.includes(user.role_slug)) {
|
||||
throw AppError.forbidden(`Action reservee au role : ${slugs.join(", ")}.`);
|
||||
}
|
||||
await next();
|
||||
};
|
||||
|
||||
export const currentUser = (context: Context): SessionUser => {
|
||||
const user = context.get("user") as SessionUser | undefined;
|
||||
if (!user) throw AppError.unauthorized();
|
||||
return user;
|
||||
};
|
||||
@@ -0,0 +1,137 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
import { pathToFileURL } from "node:url";
|
||||
import { resolve } from "node:path";
|
||||
import { ConfigError, loadDbConfig } from "./config.js";
|
||||
import { Db } from "./db.js";
|
||||
import { AppError, toSafeError } from "./errors.js";
|
||||
import { listMigrations, runMigrations } from "./migrate.js";
|
||||
|
||||
/**
|
||||
* Point d'entree des migrations : `node dist/cli.js --dir <dossier>`.
|
||||
*
|
||||
* Le conteneur de migration n'a besoin d'aucun secret lisible a la main :
|
||||
* les variables sont resolues par Docker depuis .env au lancement.
|
||||
*
|
||||
* Codes de sortie :
|
||||
* 0 tout est applique, ou rien a faire
|
||||
* 1 erreur (connexion, SQL, migration) OU derive detectee
|
||||
* 2 configuration incomplete
|
||||
*/
|
||||
|
||||
interface Options {
|
||||
dir: string;
|
||||
dryRun: boolean;
|
||||
check: boolean;
|
||||
help: boolean;
|
||||
}
|
||||
|
||||
const USAGE = `Utilisation : cohaise-migrate --dir <dossier> [--dry-run] [--check]
|
||||
|
||||
--dir <dossier> Dossier contenant les fichiers NNN_nom.sql (obligatoire)
|
||||
--dry-run Analyse sans ecrire en base
|
||||
--check Echoue s'il reste une migration a appliquer
|
||||
--help Cette aide`;
|
||||
|
||||
const parseArgs = (argv: string[]): Options => {
|
||||
const options: Options = { dir: "", dryRun: false, check: false, help: false };
|
||||
for (let index = 0; index < argv.length; index += 1) {
|
||||
const arg = argv[index];
|
||||
if (arg === undefined) continue;
|
||||
if (arg === "--dry-run") options.dryRun = true;
|
||||
else if (arg === "--check") options.check = true;
|
||||
else if (arg === "--help" || arg === "-h") options.help = true;
|
||||
else if (arg === "--dir") {
|
||||
options.dir = argv[index + 1] ?? "";
|
||||
index += 1;
|
||||
} else if (arg.startsWith("--dir=")) {
|
||||
options.dir = arg.slice("--dir=".length);
|
||||
} else {
|
||||
throw AppError.badRequest(`Argument inconnu : ${arg}`, { argument: arg });
|
||||
}
|
||||
}
|
||||
return options;
|
||||
};
|
||||
|
||||
const main = async (argv: string[]): Promise<number> => {
|
||||
let options: Options;
|
||||
try {
|
||||
options = parseArgs(argv);
|
||||
} catch (error) {
|
||||
const safe = toSafeError(error);
|
||||
console.error(` ${safe.message}\n\n${USAGE}`);
|
||||
return 2;
|
||||
}
|
||||
|
||||
if (options.help) {
|
||||
console.log(USAGE);
|
||||
return 0;
|
||||
}
|
||||
if (!options.dir) {
|
||||
console.error(` --dir est obligatoire\n\n${USAGE}`);
|
||||
return 2;
|
||||
}
|
||||
|
||||
let config;
|
||||
try {
|
||||
config = loadDbConfig();
|
||||
} catch (error) {
|
||||
if (error instanceof ConfigError) {
|
||||
console.error(` Configuration invalide :\n - ${error.issues.join("\n - ")}`);
|
||||
return 2;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
const dir = resolve(options.dir);
|
||||
const db = new Db(config);
|
||||
|
||||
try {
|
||||
const migrations = await listMigrations(dir);
|
||||
if (migrations.length === 0) {
|
||||
console.log(` Aucune migration trouvee dans ${dir}`);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const result = await runMigrations(db, dir, { dryRun: options.dryRun });
|
||||
const prefix = options.dryRun ? "[dry-run] " : "";
|
||||
|
||||
console.log(
|
||||
`${prefix}${migrations.length} migration(s) · ${result.applied.length} appliquee(s) · ` +
|
||||
`${result.skipped.length} deja en place · ${result.drifted.length} derivee(s)`,
|
||||
);
|
||||
for (const version of result.applied) console.log(` + ${version}`);
|
||||
for (const drift of result.drifted) {
|
||||
console.error(` ! ${drift.version} modifiee depuis son execution (checksum attendu ${drift.recorded.slice(0, 12)}…, trouve ${drift.current.slice(0, 12)}…)`);
|
||||
}
|
||||
|
||||
if (result.drifted.length > 0) return 1;
|
||||
if (options.check && result.applied.length > 0) return 1;
|
||||
return 0;
|
||||
} catch (error) {
|
||||
const safe = toSafeError(error);
|
||||
console.error(` Echec : ${safe.code} — ${safe.message}`);
|
||||
if (error instanceof AppError && error.status >= 500 && error.message.includes("migree")) {
|
||||
console.error(" Appliquez d'abord les migrations : cohaise-migrate --dir <dossier>");
|
||||
}
|
||||
return 1;
|
||||
} finally {
|
||||
await db.close().catch(() => undefined);
|
||||
}
|
||||
};
|
||||
|
||||
const isDirectRun =
|
||||
process.argv[1] !== undefined &&
|
||||
import.meta.url === pathToFileURL(process.argv[1]).href;
|
||||
|
||||
if (isDirectRun) {
|
||||
main(process.argv.slice(2)).then(
|
||||
(code) => process.exit(code),
|
||||
(error) => {
|
||||
console.error(` Erreur inattendue : ${error instanceof Error ? error.message : String(error)}`);
|
||||
process.exit(1);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
export { main, parseArgs };
|
||||
@@ -0,0 +1,119 @@
|
||||
import { z } from "zod";
|
||||
|
||||
/**
|
||||
* Configuration lue une seule fois au demarrage. L'objet est fige :
|
||||
* si une variable manque ou est mal formee, le processus s'arrete avant
|
||||
* d'ouvrir le moindre port, avec la liste exacte de ce qui pose probleme.
|
||||
* Une API qui demarre puis echoue sur la premiere requete est un defaut de
|
||||
* deploiement, pas un defaut d'ecriture de code.
|
||||
*/
|
||||
|
||||
const bool = (fallback: boolean) =>
|
||||
z
|
||||
.string()
|
||||
.optional()
|
||||
.transform((value) => {
|
||||
if (value === undefined || value === "") return fallback;
|
||||
return !["0", "false", "no", "off"].includes(value.toLowerCase());
|
||||
});
|
||||
|
||||
const port = (fallback: number) =>
|
||||
z.coerce.number().int().min(1).max(65535).default(fallback);
|
||||
|
||||
const positiveInt = (fallback: number) =>
|
||||
z.coerce.number().int().positive().default(fallback);
|
||||
|
||||
const schema = z.object({
|
||||
NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
|
||||
LOG_LEVEL: z.enum(["silent", "error", "warn", "info", "debug"]).default("info"),
|
||||
|
||||
PORT: port(3000),
|
||||
/** Origine publique absolue, indispensable aux liens envoyes par courriel. */
|
||||
PUBLIC_ORIGIN: z.url(),
|
||||
|
||||
DB_HOST: z.string().min(1),
|
||||
DB_PORT: port(3306),
|
||||
DB_USER: z.string().min(1),
|
||||
DB_PASSWORD: z.string().min(1),
|
||||
DB_NAME: z.string().min(1),
|
||||
|
||||
DB_CONNECTION_LIMIT: positiveInt(8),
|
||||
DB_CONNECT_TIMEOUT_MS: positiveInt(10_000),
|
||||
|
||||
MEDIA_DIR: z.string().min(1).default("/data/media/originals"),
|
||||
VARIANT_DIR: z.string().min(1).default("/data/media/variants"),
|
||||
|
||||
SESSION_SECRET: z.string().min(32),
|
||||
SESSION_TTL_HOURS: positiveInt(24 * 14),
|
||||
|
||||
TRUST_PROXY: bool(false),
|
||||
CORS_ORIGIN: z.string().optional().transform((v) => v ?? null),
|
||||
|
||||
// Envoi de courriel : obligatoire, l'application refuse de demarrer sans,
|
||||
// car la reinitialisation de mot de passe et le changement d'adresse en
|
||||
// dependent. Un relais local sans authentification reste possible : seuls
|
||||
// l'hote et l'expediteur sont exiges.
|
||||
SMTP_HOST: z.string().min(1),
|
||||
SMTP_PORT: port(587),
|
||||
SMTP_USER: z.string().optional().transform((v) => (v ? v : null)),
|
||||
SMTP_PASSWORD: z.string().optional().transform((v) => (v ? v : null)),
|
||||
SMTP_FROM: z.string().min(3),
|
||||
SMTP_SECURE: bool(false),
|
||||
/**
|
||||
* Logo des courriels. Par defaut le logo embarque (`backend/src/assets/logo.png`,
|
||||
* joint au message) ; renseigner une URL pour forcer une image distante.
|
||||
*/
|
||||
MAIL_LOGO_URL: z
|
||||
.string()
|
||||
.optional()
|
||||
.transform((v) => (v ? v : null)),
|
||||
|
||||
// Limitation des tentatives de connexion, appliquee dans le processus.
|
||||
RATE_LIMIT_LOGIN_MAX: positiveInt(10),
|
||||
RATE_LIMIT_LOGIN_WINDOW_MS: positiveInt(60_000),
|
||||
});
|
||||
|
||||
export type Config = Readonly<z.infer<typeof schema>>;
|
||||
|
||||
export class ConfigError extends Error {
|
||||
readonly issues: string[];
|
||||
constructor(issues: string[]) {
|
||||
super(`Configuration invalide (${issues.length}) :\n - ${issues.join("\n - ")}`);
|
||||
this.name = "ConfigError";
|
||||
this.issues = issues;
|
||||
}
|
||||
}
|
||||
|
||||
export const loadConfig = (env: NodeJS.ProcessEnv = process.env): Config => {
|
||||
const parsed = schema.safeParse(env);
|
||||
if (!parsed.success) throw new ConfigError(issuesOf(parsed.error));
|
||||
return Object.freeze(parsed.data);
|
||||
};
|
||||
|
||||
/** Sous-ensemble DB, pour les outils qui n'ouvrent aucun port (migrations, CLI). */
|
||||
const dbSchema = z.object({
|
||||
NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
|
||||
LOG_LEVEL: z.enum(["silent", "error", "warn", "info", "debug"]).default("info"),
|
||||
DB_HOST: z.string().min(1),
|
||||
DB_PORT: port(3306),
|
||||
DB_USER: z.string().min(1),
|
||||
DB_PASSWORD: z.string().min(1),
|
||||
DB_NAME: z.string().min(1),
|
||||
DB_CONNECTION_LIMIT: positiveInt(8),
|
||||
DB_CONNECT_TIMEOUT_MS: positiveInt(10_000),
|
||||
});
|
||||
|
||||
export type DbConfig = Readonly<z.infer<typeof dbSchema>>;
|
||||
|
||||
export const loadDbConfig = (env: NodeJS.ProcessEnv = process.env): DbConfig => {
|
||||
const parsed = dbSchema.safeParse(env);
|
||||
if (!parsed.success) throw new ConfigError(issuesOf(parsed.error));
|
||||
return Object.freeze(parsed.data);
|
||||
};
|
||||
|
||||
const issuesOf = (error: z.ZodError): string[] =>
|
||||
error.issues.map((issue) => {
|
||||
const path = issue.path.join(".") || "(racine)";
|
||||
const missing = issue.code === "invalid_type" && issue.input === undefined;
|
||||
return missing ? `${path} : variable absente` : `${path} : ${issue.message}`;
|
||||
});
|
||||
@@ -0,0 +1,107 @@
|
||||
import mysql, { type Pool, type PoolConnection, type ResultSetHeader, type RowDataPacket } from "mysql2/promise";
|
||||
import type { DbConfig } from "./config.js";
|
||||
|
||||
export interface QueryError {
|
||||
code: string;
|
||||
errno: number;
|
||||
sqlMessage?: string;
|
||||
}
|
||||
|
||||
export class Db {
|
||||
readonly pool: Pool;
|
||||
|
||||
constructor(config: DbConfig) {
|
||||
this.pool = mysql.createPool({
|
||||
host: config.DB_HOST,
|
||||
port: config.DB_PORT,
|
||||
user: config.DB_USER,
|
||||
password: config.DB_PASSWORD,
|
||||
database: config.DB_NAME,
|
||||
waitForConnections: true,
|
||||
connectionLimit: config.DB_CONNECTION_LIMIT,
|
||||
connectTimeout: config.DB_CONNECT_TIMEOUT_MS,
|
||||
timezone: "Z",
|
||||
charset: "utf8mb4_unicode_ci",
|
||||
decimalNumbers: true,
|
||||
// Porte refermee sur les requetes empilees : sans cet option, une
|
||||
// contamination d'une lecture echappait en INSERT ou en DROP. Les valeurs
|
||||
// sont toujours transmises en parametres, jamais concatenees dans le SQL.
|
||||
multipleStatements: false,
|
||||
namedPlaceholders: false,
|
||||
});
|
||||
}
|
||||
|
||||
/** Lecture en protocole prepare : les valeurs sont binaires, jamais des chains de texte. */
|
||||
async query<T = RowDataPacket>(sql: string, params: unknown[] = []): Promise<T[]> {
|
||||
const [rows] = await this.pool.execute(sql, params as never);
|
||||
return rows as T[];
|
||||
}
|
||||
|
||||
/** Requete brute, sans parametres, reservee au DDL des migrations.
|
||||
Certains etats DDL ne passent pas le protocole prepare de MariaDB. */
|
||||
async raw(sql: string): Promise<void> {
|
||||
await this.pool.query(sql);
|
||||
}
|
||||
|
||||
async one<T = RowDataPacket>(sql: string, params: unknown[] = []): Promise<T | null> {
|
||||
const rows = await this.query<RowDataPacket>(sql, params);
|
||||
return (rows[0] as T | undefined) ?? null;
|
||||
}
|
||||
|
||||
/** Le premier resultat, ou une erreur explicite plutot qu'un undefined silencieux. */
|
||||
async required<T = RowDataPacket>(sql: string, params: unknown[] = []): Promise<T> {
|
||||
const row = await this.one<T>(sql, params);
|
||||
if (row === null) {
|
||||
throw Object.assign(new Error("Ligne introuvable"), { status: 404, code: "NOT_FOUND" });
|
||||
}
|
||||
return row;
|
||||
}
|
||||
|
||||
async exec(sql: string, params: unknown[] = []): Promise<ResultSetHeader> {
|
||||
const [result] = await this.pool.execute(sql, params as never);
|
||||
return result as ResultSetHeader;
|
||||
}
|
||||
|
||||
async transaction<T>(fn: (connection: PoolConnection) => Promise<T>): Promise<T> {
|
||||
const connection = await this.pool.getConnection();
|
||||
try {
|
||||
await connection.beginTransaction();
|
||||
const result = await fn(connection);
|
||||
await connection.commit();
|
||||
return result;
|
||||
} catch (error) {
|
||||
await connection.rollback();
|
||||
throw error;
|
||||
} finally {
|
||||
connection.release();
|
||||
}
|
||||
}
|
||||
|
||||
/** Forme courte des erreurs de contrainte, pour les repondre en 409 et non en 500. */
|
||||
static classify(error: unknown): { status: number; message: string } {
|
||||
const errno = (error as { errno?: number })?.errno;
|
||||
const sqlMessage = (error as { sqlMessage?: string })?.sqlMessage ?? "";
|
||||
switch (errno) {
|
||||
case 1062:
|
||||
return { status: 409, message: "Cette valeur existe deja." };
|
||||
case 1451:
|
||||
case 1452:
|
||||
return { status: 409, message: "Operation impossible : des enregistrements en referent encore." };
|
||||
case 1406:
|
||||
return { status: 422, message: "Valeur trop longue pour la colonne." };
|
||||
case 1146:
|
||||
return { status: 503, message: "Table absente : la base n'est peut-etre pas migree." };
|
||||
case 1045:
|
||||
return { status: 503, message: "Acces refuse par la base de donnees." };
|
||||
case 1040:
|
||||
case 1203:
|
||||
return { status: 503, message: "Trop de connexions a la base de donnees." };
|
||||
default:
|
||||
return errno === undefined ? { status: 500, message: "Erreur interne." } : { status: 500, message: sqlMessage || "Erreur de base de donnees." };
|
||||
}
|
||||
}
|
||||
|
||||
async close(): Promise<void> {
|
||||
await this.pool.end();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
/**
|
||||
* Erreurs portees par un code HTTP. Une erreur qui n'en porte pas est
|
||||
* consideree interne : on journalise le detail, on ne le rend jamais au
|
||||
* client, parce que le message d'une exception ne doit pas decrire le schema.
|
||||
*/
|
||||
|
||||
export class AppError extends Error {
|
||||
readonly status: number;
|
||||
readonly code: string;
|
||||
readonly details?: Record<string, unknown>;
|
||||
|
||||
constructor(status: number, code: string, message: string, details?: Record<string, unknown>) {
|
||||
super(message);
|
||||
this.name = "AppError";
|
||||
this.status = status;
|
||||
this.code = code;
|
||||
if (details !== undefined) this.details = details;
|
||||
}
|
||||
|
||||
static badRequest(message: string, details?: Record<string, unknown>) {
|
||||
return new AppError(400, "BAD_REQUEST", message, details);
|
||||
}
|
||||
static unauthorized(message = "Authentification requise.") {
|
||||
return new AppError(401, "UNAUTHORIZED", message);
|
||||
}
|
||||
static forbidden(message = "Vous ne pouvez pas effectuer cette action.") {
|
||||
return new AppError(403, "FORBIDDEN", message);
|
||||
}
|
||||
static notFound(message = "Ressource introuvable.") {
|
||||
return new AppError(404, "NOT_FOUND", message);
|
||||
}
|
||||
static conflict(message: string) {
|
||||
return new AppError(409, "CONFLICT", message);
|
||||
}
|
||||
static payloadTooLarge(message = "Fichier trop volumineux.") {
|
||||
return new AppError(413, "PAYLOAD_TOO_LARGE", message);
|
||||
}
|
||||
static unprocessable(message: string, details?: Record<string, unknown>) {
|
||||
return new AppError(422, "UNPROCESSABLE", message, details);
|
||||
}
|
||||
static serviceUnavailable(message = "Service momentanement indisponible.") {
|
||||
return new AppError(503, "UNAVAILABLE", message);
|
||||
}
|
||||
static insufficientStorage(message = "Espace de stockage insuffisant sur le serveur.") {
|
||||
return new AppError(507, "INSUFFICIENT_STORAGE", message);
|
||||
}
|
||||
}
|
||||
|
||||
export interface SafeError {
|
||||
status: number;
|
||||
code: string;
|
||||
message: string;
|
||||
details?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export const toSafeError = (error: unknown): SafeError => {
|
||||
if (error instanceof AppError) {
|
||||
return error.details !== undefined
|
||||
? { status: error.status, code: error.code, message: error.message, details: error.details }
|
||||
: { status: error.status, code: error.code, message: error.message };
|
||||
}
|
||||
|
||||
const status = (error as { status?: number })?.status;
|
||||
const code = (error as { code?: string })?.code;
|
||||
if (typeof status === "number" && status >= 400 && status < 500) {
|
||||
return { status, code: code ?? "BAD_REQUEST", message: (error as Error).message };
|
||||
}
|
||||
|
||||
// Une erreur MariaDB connue est un probleme d'exploitation, pas un crash.
|
||||
const errno = (error as { errno?: number })?.errno;
|
||||
if (errno !== undefined) {
|
||||
const { status: dbStatus, message } = classifyDbError(errno);
|
||||
return { status: dbStatus, code: errno === 1146 ? "NOT_MIGRATED" : "DATABASE", message };
|
||||
}
|
||||
|
||||
return { status: 500, code: "INTERNAL", message: "Erreur interne." };
|
||||
};
|
||||
|
||||
const classifyDbError = (errno: number): { status: number; message: string } => {
|
||||
switch (errno) {
|
||||
case 1062:
|
||||
return { status: 409, message: "Cette valeur existe deja." };
|
||||
case 1451:
|
||||
case 1452:
|
||||
return { status: 409, message: "Operation impossible : des enregistrements en referent encore." };
|
||||
case 1406:
|
||||
return { status: 422, message: "Valeur trop longue pour la colonne." };
|
||||
case 1146:
|
||||
return { status: 503, message: "Base non migree. Lancez les migrations avant de servir." };
|
||||
case 1045:
|
||||
return { status: 503, message: "Acces refuse par la base de donnees." };
|
||||
case 1040:
|
||||
case 1203:
|
||||
return { status: 503, message: "Trop de connexions a la base de donnees." };
|
||||
case 1053:
|
||||
return { status: 503, message: "Base de donnees en cours d'initialisation." };
|
||||
default:
|
||||
return { status: 503, message: "Base de donnees indisponible." };
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,171 @@
|
||||
import { randomUUID } from "node:crypto";
|
||||
import { Hono, type Context, type Next } from "hono";
|
||||
import { cors } from "hono/cors";
|
||||
import type { SessionUser } from "./auth.js";
|
||||
import type { Config } from "./config.js";
|
||||
import type { Db } from "./db.js";
|
||||
import { AppError, toSafeError } from "./errors.js";
|
||||
|
||||
export interface Logger {
|
||||
level: Config["LOG_LEVEL"];
|
||||
info: (message: string, fields?: Record<string, unknown>) => void;
|
||||
warn: (message: string, fields?: Record<string, unknown>) => void;
|
||||
error: (message: string, fields?: Record<string, unknown>) => void;
|
||||
debug: (message: string, fields?: Record<string, unknown>) => void;
|
||||
}
|
||||
|
||||
const ORDER: Record<Config["LOG_LEVEL"], number> = {
|
||||
silent: 0,
|
||||
error: 1,
|
||||
warn: 2,
|
||||
info: 3,
|
||||
debug: 4,
|
||||
};
|
||||
|
||||
export const createLogger = (level: Config["LOG_LEVEL"], service: string): Logger => {
|
||||
const emit = (name: keyof typeof ORDER, message: string, fields?: Record<string, unknown>) => {
|
||||
if (ORDER[name] > ORDER[level]) return;
|
||||
const line = JSON.stringify({
|
||||
ts: new Date().toISOString(),
|
||||
level: name,
|
||||
service,
|
||||
msg: message,
|
||||
...fields,
|
||||
});
|
||||
if (name === "error") console.error(line);
|
||||
else console.log(line);
|
||||
};
|
||||
|
||||
return {
|
||||
level,
|
||||
info: (message, fields) => emit("info", message, fields),
|
||||
warn: (message, fields) => emit("warn", message, fields),
|
||||
error: (message, fields) => emit("error", message, fields),
|
||||
debug: (message, fields) => emit("debug", message, fields),
|
||||
};
|
||||
};
|
||||
|
||||
/** Variables transportees par chaque requete : tracee d'identification. */
|
||||
export interface AppEnv {
|
||||
Variables: {
|
||||
requestId: string;
|
||||
/** Posee par attachUser quand le cookie de session est valide. */
|
||||
user?: SessionUser;
|
||||
token?: string;
|
||||
};
|
||||
}
|
||||
|
||||
/** Type public d'une application CoHaiSe, impose aux routes metier. */
|
||||
export type App = Hono<AppEnv>;
|
||||
|
||||
/**
|
||||
* IP reelle de l'appelant : X-Forwarded-For n'est cru que si le service fait
|
||||
* confiance a son proxy. La valeur est tronquee a la taille de la colonne.
|
||||
*/
|
||||
export const clientIp = (context: Context, trustProxy: boolean): string | null => {
|
||||
if (trustProxy) {
|
||||
const forwarded = context.req.header("x-forwarded-for");
|
||||
const first = forwarded?.split(",")[0]?.trim();
|
||||
if (first) return first.slice(0, 45);
|
||||
}
|
||||
const env = context.env as
|
||||
| { incoming?: { socket?: { remoteAddress?: string } } }
|
||||
| undefined;
|
||||
const address = env?.incoming?.socket?.remoteAddress;
|
||||
return address ? address.slice(0, 45) : null;
|
||||
};
|
||||
|
||||
/** Dependances remises aux routes metier au montage. */
|
||||
export interface RouteDeps {
|
||||
db: Db;
|
||||
config: Config;
|
||||
logger: Logger;
|
||||
}
|
||||
|
||||
export interface AppOptions {
|
||||
service: string;
|
||||
config: Config;
|
||||
db: Db;
|
||||
logger: Logger;
|
||||
/** Routes metier, montees sous /api/<service> dans le routing. */
|
||||
routes: (app: App, deps: RouteDeps) => void;
|
||||
/** Vrai quand l'API doit repondre a /healthz avec l'etat de la base. */
|
||||
probeDb?: boolean;
|
||||
}
|
||||
|
||||
export const createApp = ({ service, config, db, logger, routes, probeDb = true }: AppOptions): App => {
|
||||
const app = new Hono<AppEnv>();
|
||||
|
||||
app.use("*", async (context: Context, next: Next) => {
|
||||
const requestId = context.req.header("x-request-id") ?? randomUUID();
|
||||
context.set("requestId", requestId);
|
||||
context.res.headers.set("x-request-id", requestId);
|
||||
context.res.headers.set("x-content-type-options", "nosniff");
|
||||
context.res.headers.set("referrer-policy", "same-origin");
|
||||
context.res.headers.set("x-frame-options", "DENY");
|
||||
const started = performance.now();
|
||||
await next();
|
||||
const duration = Math.round(performance.now() - started);
|
||||
if (context.req.method !== "OPTIONS") {
|
||||
logger.debug("requete", {
|
||||
requestId,
|
||||
method: context.req.method,
|
||||
path: new URL(context.req.url).pathname,
|
||||
status: context.res.status,
|
||||
durationMs: duration,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
if (config.CORS_ORIGIN) {
|
||||
app.use(
|
||||
"*",
|
||||
cors({
|
||||
origin: config.CORS_ORIGIN.split(",").map((value) => value.trim()),
|
||||
credentials: true,
|
||||
maxAge: 600,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
app.get("/healthz", async (context) => {
|
||||
if (!probeDb) return context.json({ status: "ok", service }, 200);
|
||||
const started = performance.now();
|
||||
try {
|
||||
await db.query("SELECT 1");
|
||||
return context.json(
|
||||
{ status: "ok", service, db: "up", latencyMs: Math.round(performance.now() - started) },
|
||||
200,
|
||||
);
|
||||
} catch (error) {
|
||||
logger.error("sante base en echec", { error: String(error) });
|
||||
return context.json({ status: "degraded", service, db: "down" }, 503);
|
||||
}
|
||||
});
|
||||
|
||||
routes(app, { db, config, logger });
|
||||
|
||||
app.notFound((context) =>
|
||||
context.json({ error: { status: 404, code: "NOT_FOUND", message: "Route introuvable." } }, 404),
|
||||
);
|
||||
|
||||
app.onError((error, context) => {
|
||||
const safe = toSafeError(error);
|
||||
const requestId = context.get("requestId");
|
||||
if (safe.status >= 500) {
|
||||
logger.error("erreur non geree", {
|
||||
requestId,
|
||||
code: safe.code,
|
||||
message: error instanceof Error ? error.message : String(error),
|
||||
stack: error instanceof Error ? error.stack : undefined,
|
||||
});
|
||||
} else {
|
||||
logger.debug("refus", { requestId, code: safe.code, status: safe.status });
|
||||
}
|
||||
return context.json({ error: { ...safe, requestId } }, safe.status as 500);
|
||||
});
|
||||
|
||||
return app;
|
||||
};
|
||||
|
||||
export { AppError };
|
||||
@@ -0,0 +1,57 @@
|
||||
export {
|
||||
loadConfig,
|
||||
loadDbConfig,
|
||||
ConfigError,
|
||||
type Config,
|
||||
type DbConfig,
|
||||
} from "./config.js";
|
||||
export { Db } from "./db.js";
|
||||
export { AppError, toSafeError, type SafeError } from "./errors.js";
|
||||
export {
|
||||
createApp,
|
||||
createLogger,
|
||||
clientIp,
|
||||
type App,
|
||||
type AppEnv,
|
||||
type AppOptions,
|
||||
type Logger,
|
||||
type RouteDeps,
|
||||
} from "./http.js";
|
||||
export {
|
||||
attachUser,
|
||||
clearSessionCookie,
|
||||
createSession,
|
||||
currentUser,
|
||||
isHttpsRequest,
|
||||
hashPassword,
|
||||
requireAuth,
|
||||
requireRole,
|
||||
purgeExpiredSessions,
|
||||
revokeSession,
|
||||
SESSION_COOKIE,
|
||||
setSessionCookie,
|
||||
sha256,
|
||||
verifyPassword,
|
||||
type SessionUser,
|
||||
} from "./auth.js";
|
||||
export {
|
||||
listMigrations,
|
||||
runMigrations,
|
||||
assertNoDrift,
|
||||
type MigrationResult,
|
||||
} from "./migrate.js";
|
||||
export { createMailer, link, type Mailer, type MailMessage } from "./mail.js";
|
||||
export {
|
||||
branding,
|
||||
renderMail,
|
||||
type Branding,
|
||||
type MailContent,
|
||||
type RenderedMail,
|
||||
} from "./mail-template.js";
|
||||
export { createRateLimiter, rateLimitKey, type RateLimiter } from "./ratelimit.js";
|
||||
export {
|
||||
prepareService,
|
||||
startService,
|
||||
type Service,
|
||||
type ServiceOptions,
|
||||
} from "./service.js";
|
||||
@@ -0,0 +1,147 @@
|
||||
import type { Config } from "./config.js";
|
||||
|
||||
/**
|
||||
* Gabarit de courriel de marque, sans dependance ni feuille de style externe :
|
||||
* les clients de messagerie n'interpretent qu'une partie du CSS, tout est donc
|
||||
* ecrit en ligne et pose sur des tableaux, y compris pour Outlook.
|
||||
*/
|
||||
|
||||
export interface Branding {
|
||||
appName: string;
|
||||
origin: string;
|
||||
logoUrl: string;
|
||||
color: string;
|
||||
/** Adresse d'expedition, reprise en pied pour dire ou ne pas repondre. */
|
||||
footer: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Identifiant de la piece jointe du logo. Le logo est embarque dans le message
|
||||
* (voir `mail.ts`) : l'image s'affiche meme si le client bloque les ressources
|
||||
* distantes. `MAIL_LOGO_URL` force une image distante a la place.
|
||||
*/
|
||||
export const LOGO_CID = "cohaise-logo";
|
||||
|
||||
export const branding = (config: Config): Branding => ({
|
||||
appName: "CoHaiSe Cloud",
|
||||
origin: config.PUBLIC_ORIGIN,
|
||||
logoUrl: config.MAIL_LOGO_URL ?? `cid:${LOGO_CID}`,
|
||||
color: "#b71c1c",
|
||||
footer: config.SMTP_FROM,
|
||||
});
|
||||
|
||||
export interface MailContent {
|
||||
/** Aperçu affiche par le client, avant ouverture (texte brut). */
|
||||
preview: string;
|
||||
heading: string;
|
||||
intro: string;
|
||||
paragraphs?: string[];
|
||||
/** Identifiants d'acces, presentes dans un encadre monospace. */
|
||||
credentials?: { email: string; password: string };
|
||||
cta?: { label: string; url: string };
|
||||
note?: string;
|
||||
}
|
||||
|
||||
export interface RenderedMail {
|
||||
html: string;
|
||||
text: string;
|
||||
}
|
||||
|
||||
const escapeHtml = (value: string): string =>
|
||||
value
|
||||
.replace(/&/g, "&")
|
||||
.replace(/</g, "<")
|
||||
.replace(/>/g, ">")
|
||||
.replace(/"/g, """)
|
||||
.replace(/'/g, "'");
|
||||
|
||||
const FONT = "-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif";
|
||||
|
||||
export const renderMail = (brand: Branding, content: MailContent): RenderedMail => {
|
||||
const paragraphs = (content.paragraphs ?? [])
|
||||
.map(
|
||||
(paragraph) =>
|
||||
`<p style="margin:0 0 16px;font-size:15px;line-height:1.6;color:#c9c2c2;text-align:center;">${escapeHtml(paragraph)}</p>`,
|
||||
)
|
||||
.join("");
|
||||
|
||||
const credentials = content.credentials
|
||||
? `
|
||||
<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="margin:0 auto 26px;max-width:420px;background:#1b1212;border:1px solid #332222;border-radius:10px;">
|
||||
<tr><td style="padding:16px 18px;font-family:${FONT};text-align:left;">
|
||||
<p style="margin:0 0 10px;font:600 12px ${FONT};letter-spacing:.04em;text-transform:uppercase;color:#9c9292;">Vos identifiants</p>
|
||||
<p style="margin:0 0 6px;font:400 14px ${FONT};color:#c9c2c2;">Adresse : <strong style="color:#f7f5f5;">${escapeHtml(content.credentials.email)}</strong></p>
|
||||
<p style="margin:0;font:400 14px ${FONT};color:#c9c2c2;">Mot de passe temporaire :
|
||||
<span style="font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:14px;background:#241818;border:1px solid #3a2828;border-radius:6px;padding:2px 8px;color:#f7f5f5;">${escapeHtml(content.credentials.password)}</span>
|
||||
</p>
|
||||
</td></tr>
|
||||
</table>`
|
||||
: "";
|
||||
|
||||
const cta = content.cta
|
||||
? `
|
||||
<table role="presentation" cellpadding="0" cellspacing="0" align="center" style="margin:0 auto 26px;">
|
||||
<tr><td align="center" style="background:${brand.color};border-radius:10px;">
|
||||
<a href="${escapeHtml(content.cta.url)}" style="display:inline-block;padding:14px 32px;font:600 15px ${FONT};color:#ffffff;text-decoration:none;">${escapeHtml(content.cta.label)}</a>
|
||||
</td></tr>
|
||||
</table>`
|
||||
: "";
|
||||
|
||||
const note = content.note
|
||||
? `
|
||||
<p style="margin:0;font:400 13px ${FONT};line-height:1.6;color:#8a8282;text-align:center;">${escapeHtml(content.note)}</p>`
|
||||
: "";
|
||||
|
||||
const html = `<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<meta name="color-scheme" content="dark only">
|
||||
<meta name="supported-color-schemes" content="dark only">
|
||||
<title>${escapeHtml(content.heading)}</title>
|
||||
</head>
|
||||
<body style="margin:0;padding:0;background:#050000;">
|
||||
<div style="display:none;max-height:0;overflow:hidden;opacity:0;color:#050000;">${escapeHtml(content.preview)}</div>
|
||||
<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#050000;padding:32px 12px;">
|
||||
<tr><td align="center">
|
||||
<table role="presentation" width="560" cellpadding="0" cellspacing="0" style="width:100%;max-width:560px;background:#140d0d;border:1px solid #2a1c1c;border-radius:14px;overflow:hidden;">
|
||||
<tr><td style="background:${brand.color};padding:17px 28px;text-align:center;">
|
||||
<span style="font:700 14px ${FONT};letter-spacing:.18em;text-transform:uppercase;color:#ffffff;">${escapeHtml(brand.appName)}</span>
|
||||
</td></tr>
|
||||
<tr><td style="padding:40px 30px 6px;font-family:${FONT};text-align:center;">
|
||||
<h1 style="margin:0 0 18px;font:700 28px ${FONT};line-height:1.25;color:#f7f5f5;">${escapeHtml(content.heading)}</h1>
|
||||
<p style="margin:0 0 28px;font:400 15px ${FONT};line-height:1.65;color:#c9c2c2;">${escapeHtml(content.intro)}</p>
|
||||
</td></tr>
|
||||
<tr><td style="padding:0 30px 14px;font-family:${FONT};text-align:center;">
|
||||
${paragraphs}${credentials}${cta}${note}
|
||||
</td></tr>
|
||||
<tr><td style="padding:20px 28px 24px;background:#0d0808;border-top:1px solid #2a1c1c;">
|
||||
<table role="presentation" width="100%" cellpadding="0" cellspacing="0">
|
||||
<tr>
|
||||
<td style="vertical-align:middle;font-family:${FONT};">
|
||||
<p style="margin:0 0 4px;font:400 12px ${FONT};line-height:1.6;color:#8a8282;">Message automatique : merci de ne pas repondre a cet e-mail.</p>
|
||||
<p style="margin:0;font:400 12px ${FONT};line-height:1.6;color:#8a8282;">${escapeHtml(brand.footer)}</p>
|
||||
</td>
|
||||
<td align="right" style="vertical-align:middle;padding-left:16px;">
|
||||
<img src="${escapeHtml(brand.logoUrl)}" width="44" height="44" alt="" style="display:block;border:0;border-radius:10px;background:#ffffff;">
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
</td></tr>
|
||||
</table>
|
||||
</td></tr>
|
||||
</table>
|
||||
</body>
|
||||
</html>`;
|
||||
|
||||
const lines = [content.intro, ...(content.paragraphs ?? [])];
|
||||
if (content.credentials) {
|
||||
lines.push(`Adresse : ${content.credentials.email}`, `Mot de passe temporaire : ${content.credentials.password}`);
|
||||
}
|
||||
if (content.cta) lines.push(`${content.cta.label} : ${content.cta.url}`);
|
||||
if (content.note) lines.push(content.note);
|
||||
lines.push("", "Message automatique : merci de ne pas repondre a cet e-mail.", brand.footer);
|
||||
|
||||
return { html, text: lines.join("\n") };
|
||||
};
|
||||
@@ -0,0 +1,75 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { createTransport, type Transporter } from "nodemailer";
|
||||
import type { Config } from "./config.js";
|
||||
import { LOGO_CID } from "./mail-template.js";
|
||||
|
||||
/**
|
||||
* Envoi de courriel via SMTP.
|
||||
*
|
||||
* Le transport est construit une seule fois au demarrage. L'application exige
|
||||
* les variables SMTP_* : sans elles, elle refuse de demarrer plutot que de
|
||||
* laisser une reinitialisation de mot de passe silencieusement sans effet.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Logo embarque dans les messages. Le chemin remonte depuis `src/lib` ou
|
||||
* `dist/lib` vers `backend/src/assets/logo.png`, present dans l'image.
|
||||
*/
|
||||
const LOGO_PATH = new URL("../../src/assets/logo.png", import.meta.url);
|
||||
|
||||
const loadLogo = (): Buffer | null => {
|
||||
try {
|
||||
return readFileSync(LOGO_PATH);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
export interface MailMessage {
|
||||
to: string;
|
||||
subject: string;
|
||||
text: string;
|
||||
/** Version enrichie ; les clients texte recoivent `text`, les autres `html`. */
|
||||
html?: string;
|
||||
}
|
||||
|
||||
export interface Mailer {
|
||||
send: (message: MailMessage) => Promise<void>;
|
||||
}
|
||||
|
||||
export const createMailer = (config: Config): Mailer => {
|
||||
const transport: Transporter = createTransport({
|
||||
host: config.SMTP_HOST,
|
||||
port: config.SMTP_PORT,
|
||||
secure: config.SMTP_SECURE,
|
||||
...(config.SMTP_USER
|
||||
? { auth: { user: config.SMTP_USER, pass: config.SMTP_PASSWORD ?? "" } }
|
||||
: {}),
|
||||
disableFileAccess: true,
|
||||
disableUrlAccess: true,
|
||||
});
|
||||
|
||||
// Logo embarque une seule fois. `MAIL_LOGO_URL` le remplace par une image
|
||||
// distante : dans ce cas on n'attache rien.
|
||||
const logo = config.MAIL_LOGO_URL ? null : loadLogo();
|
||||
|
||||
return {
|
||||
send: async (message) => {
|
||||
const inlineLogo = logo !== null && message.html?.includes(`cid:${LOGO_CID}`) === true;
|
||||
await transport.sendMail({
|
||||
from: config.SMTP_FROM,
|
||||
to: message.to,
|
||||
subject: message.subject,
|
||||
text: message.text,
|
||||
...(message.html ? { html: message.html } : {}),
|
||||
...(inlineLogo
|
||||
? { attachments: [{ filename: "logo.png", content: logo, cid: LOGO_CID }] }
|
||||
: {}),
|
||||
});
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
/** Lien absolu construit sur PUBLIC_ORIGIN, qui est valide au demarrage. */
|
||||
export const link = (config: Config, path: string): string =>
|
||||
new URL(path, config.PUBLIC_ORIGIN).toString();
|
||||
@@ -0,0 +1,144 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { readdir, readFile } from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
import type { Db } from "./db.js";
|
||||
|
||||
/**
|
||||
* Applique les fichiers NNN_nom.sql dans l'ordre lexical, et uniquement ceux
|
||||
* qui ne sont pas encore marques comme appliques. Idempotent : un second appel
|
||||
* ne reexecute rien.
|
||||
*
|
||||
* Limite connue et assumee : le DDL MariaDB n'est pas transactionnel. Un fichier
|
||||
* echoue au milieu, le reste des statements n'est pas applique et le fichier
|
||||
* n'est pas enregistre. Le repasser reprend depuis son debut. C'est pourquoi
|
||||
* chaque migration part de la ou la precedente a fini, et pourquoi une migration
|
||||
* en desordre doit etre reparue et pas seulement sauvegardee depuis sa moitie.
|
||||
*/
|
||||
|
||||
export interface MigrationFile {
|
||||
version: string;
|
||||
file: string;
|
||||
sql: string;
|
||||
checksum: string;
|
||||
}
|
||||
|
||||
export interface MigrationResult {
|
||||
applied: string[];
|
||||
skipped: string[];
|
||||
/** Migrations deja appliquees dont le contenu du fichier a change depuis. */
|
||||
drifted: { version: string; recorded: string; current: string }[];
|
||||
}
|
||||
|
||||
// Les deux bases utilisent un prefixe a trois chiffres (000, 001, …) ;
|
||||
// quatre est accepte pour ne pas interdire le passage a un dossier plus large.
|
||||
const FILE_PATTERN = /^(\d{3,4}_[a-z0-9_]+)\.sql$/;
|
||||
|
||||
export const listMigrations = async (dir: string): Promise<MigrationFile[]> => {
|
||||
const entries = await readdir(dir);
|
||||
const files = entries.filter((entry) => FILE_PATTERN.test(entry)).sort();
|
||||
|
||||
return Promise.all(
|
||||
files.map(async (file) => {
|
||||
const sql = await readFile(path.join(dir, file), "utf8");
|
||||
return {
|
||||
version: FILE_PATTERN.exec(file)?.[1] ?? file,
|
||||
file,
|
||||
sql,
|
||||
checksum: createHash("sha256").update(sql).digest("hex"),
|
||||
};
|
||||
}),
|
||||
);
|
||||
};
|
||||
|
||||
const ensureLedger = async (db: Db): Promise<void> => {
|
||||
await db.raw(`
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version VARCHAR(64) NOT NULL,
|
||||
applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
PRIMARY KEY (version)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
||||
`);
|
||||
// Creer la colonne ici plutot que dans une migration : ajouter une ligne a un
|
||||
// registre qui enregistre lui-meme les lignes ajoutees boucle sur lui-meme.
|
||||
await db.raw(
|
||||
"ALTER TABLE schema_migrations ADD COLUMN IF NOT EXISTS checksum CHAR(64) NULL AFTER applied_at",
|
||||
);
|
||||
};
|
||||
|
||||
export const runMigrations = async (
|
||||
db: Db,
|
||||
dir: string,
|
||||
options: { dryRun?: boolean } = {},
|
||||
): Promise<MigrationResult> => {
|
||||
const files = await listMigrations(dir);
|
||||
await ensureLedger(db);
|
||||
|
||||
const applied = new Map<string, { checksum: string | null }>();
|
||||
const rows = await db.query<{ version: string; checksum: string | null }>(
|
||||
"SELECT version, checksum FROM schema_migrations",
|
||||
);
|
||||
for (const row of rows) applied.set(row.version, { checksum: row.checksum });
|
||||
|
||||
const result: MigrationResult = { applied: [], skipped: [], drifted: [] };
|
||||
|
||||
for (const migration of files) {
|
||||
const record = applied.get(migration.version);
|
||||
|
||||
if (record) {
|
||||
result.skipped.push(migration.version);
|
||||
if (record.checksum && record.checksum !== migration.checksum) {
|
||||
result.drifted.push({
|
||||
version: migration.version,
|
||||
recorded: record.checksum,
|
||||
current: migration.checksum,
|
||||
});
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (options.dryRun) {
|
||||
result.applied.push(migration.version);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Un statement par un statement : un filet de faille reste visible et le
|
||||
// point d'arret reste reproductible plutot qu'un bloc de 400 lignes perdu.
|
||||
//
|
||||
// Les lignes de commentaire sont retirees, pas le statement entier : un
|
||||
// en-tete de fichier ou une legende au-dessus d'un INSERT ne doit pas
|
||||
// faire sauter la requete, et encore moins la faire sauter en silence
|
||||
// pendant que la version est enregistree comme appliquee.
|
||||
const statements = migration.sql
|
||||
.split(/;\s*(?:\r?\n|$)/)
|
||||
.map((statement) =>
|
||||
statement
|
||||
.split(/\r?\n/)
|
||||
.filter((line) => !line.trim().startsWith("--"))
|
||||
.join("\n")
|
||||
.trim(),
|
||||
)
|
||||
.filter((statement) => statement.length > 0);
|
||||
|
||||
for (const statement of statements) await db.raw(statement);
|
||||
|
||||
await db.exec("INSERT INTO schema_migrations (version, checksum) VALUES (?, ?)", [
|
||||
migration.version,
|
||||
migration.checksum,
|
||||
]);
|
||||
result.applied.push(migration.version);
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
export const assertNoDrift = (result: MigrationResult): void => {
|
||||
if (result.drifted.length === 0) return;
|
||||
const lines = result.drifted.map(
|
||||
(d) => ` ${d.version} : appliquee ${d.recorded.slice(0, 12)}, fichier ${d.current.slice(0, 12)}`,
|
||||
);
|
||||
throw new Error(
|
||||
`Migrations deja appliquees modifiees depuis leur execution (${result.drifted.length}) :\n` +
|
||||
`${lines.join("\n")}\n` +
|
||||
"Une migration appliquee ne se modifie pas : creez un nouveau fichier.",
|
||||
);
|
||||
};
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Limiteur de debit en memoire.
|
||||
*
|
||||
* Volontairement minimal : une seule instance d'API, donc un simple compteur
|
||||
* glissant par cle suffit. La protection robuste contre une attaque repartie
|
||||
* vit dans nginx (`limit_req`) ; celle-ci couvre le cas ou l'API est jointe
|
||||
* directement, sans proxy.
|
||||
*
|
||||
* La memoire est bornee : les entrees purgees a chaque appel ne s'accumulent
|
||||
* pas, et une entree dont toutes les tentatives sont sorties de la fenetre est
|
||||
* oubliee.
|
||||
*/
|
||||
|
||||
interface Bucket {
|
||||
count: number;
|
||||
resetAt: number;
|
||||
}
|
||||
|
||||
export interface RateLimiter {
|
||||
/** Vrai quand la tentative est permise ; faux une fois la borne atteinte. */
|
||||
allow: (key: string) => boolean;
|
||||
}
|
||||
|
||||
export const createRateLimiter = (max: number, windowMs: number): RateLimiter => {
|
||||
const buckets = new Map<string, Bucket>();
|
||||
|
||||
const prune = (now: number): void => {
|
||||
for (const [key, bucket] of buckets) {
|
||||
if (bucket.resetAt <= now) buckets.delete(key);
|
||||
}
|
||||
};
|
||||
|
||||
return {
|
||||
allow: (key) => {
|
||||
const now = Date.now();
|
||||
// Purge a chaque appel : le cout est proportionnel au nombre de cles
|
||||
// actives, borne par la fenetre, jamais par l'historique complet.
|
||||
prune(now);
|
||||
const bucket = buckets.get(key);
|
||||
if (!bucket || bucket.resetAt <= now) {
|
||||
buckets.set(key, { count: 1, resetAt: now + windowMs });
|
||||
return true;
|
||||
}
|
||||
if (bucket.count >= max) return false;
|
||||
bucket.count += 1;
|
||||
return true;
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
/** Identifiant de limitation : IP reelle si le proxy est de confiance, sinon socket. */
|
||||
export const rateLimitKey = (ip: string | null): string => ip ?? "unknown";
|
||||
@@ -0,0 +1,152 @@
|
||||
import { createServer, type Server } from "node:http";
|
||||
import { type AddressInfo } from "node:net";
|
||||
import { getRequestListener } from "@hono/node-server";
|
||||
import { ConfigError, loadConfig, type Config } from "./config.js";
|
||||
import { AppError } from "./errors.js";
|
||||
import { Db } from "./db.js";
|
||||
import {
|
||||
createLogger,
|
||||
createApp,
|
||||
type App,
|
||||
type AppOptions,
|
||||
type Logger,
|
||||
type RouteDeps,
|
||||
} from "./http.js";
|
||||
import { assertNoDrift, runMigrations } from "./migrate.js";
|
||||
|
||||
export interface ServiceOptions {
|
||||
service: string;
|
||||
/** Dossier contenant les fichiers NNN_nom.sql de cette application. */
|
||||
migrationsDir?: string;
|
||||
routes: (app: App, deps: RouteDeps) => void;
|
||||
probeDb?: boolean;
|
||||
/**
|
||||
* Tache d'entretien executee une fois la base joignable et migree, avant
|
||||
* l'ouverture du port (purge des sessions ou de la corbeille).
|
||||
*/
|
||||
onReady?: (deps: RouteDeps) => Promise<void> | void;
|
||||
}
|
||||
|
||||
export interface Service {
|
||||
config: Config;
|
||||
db: Db;
|
||||
logger: Logger;
|
||||
app: App;
|
||||
}
|
||||
|
||||
const fail = (error: unknown): never => {
|
||||
if (error instanceof ConfigError) {
|
||||
console.error(`\n [${new Date().toISOString()}] Demarrage refuse\n`);
|
||||
console.error(error.message);
|
||||
console.error(
|
||||
"\n Verifiez .env (ou les variables du conteneur). .env.example recense l'ensemble du format attendu.\n",
|
||||
);
|
||||
} else {
|
||||
console.error(
|
||||
`\n [${new Date().toISOString()}] Demarrage refuse : ${
|
||||
error instanceof Error ? error.message : String(error)
|
||||
}\n`,
|
||||
);
|
||||
if (error instanceof Error && error.stack) console.error(error.stack);
|
||||
}
|
||||
process.exit(1);
|
||||
};
|
||||
|
||||
/**
|
||||
* Prepare le service sans lancer d'ecoute. Utile pour la CLI de migration et
|
||||
* pour les tests, qui n'ont pas besoin d'un port.
|
||||
*/
|
||||
export const prepareService = async (options: ServiceOptions): Promise<Service> => {
|
||||
const config = loadConfig();
|
||||
const logger = createLogger(config.LOG_LEVEL, options.service);
|
||||
const db = new Db(config);
|
||||
|
||||
if (options.migrationsDir) {
|
||||
const result = await runMigrations(db, options.migrationsDir);
|
||||
assertNoDrift(result);
|
||||
if (result.applied.length > 0) {
|
||||
logger.info("migrations appliquees", { versions: result.applied });
|
||||
}
|
||||
if (result.drifted.length > 0) {
|
||||
logger.warn("migrations modifiees depuis leur execution", {
|
||||
versions: result.drifted.map((d) => d.version),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (options.onReady) {
|
||||
try {
|
||||
await options.onReady({ db, config, logger });
|
||||
} catch (error) {
|
||||
// L'entretien ne doit jamais empecher de servir : une purge en echec est
|
||||
// signalee, la base reste exploitable.
|
||||
logger.error("tache de demarrage en echec", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const app = createApp({
|
||||
service: options.service,
|
||||
config,
|
||||
db,
|
||||
logger,
|
||||
routes: options.routes,
|
||||
probeDb: options.probeDb ?? true,
|
||||
});
|
||||
|
||||
return { config, db, logger, app };
|
||||
};
|
||||
|
||||
/** Demarre, ecoute, et s'arrete proprement. */
|
||||
export const startService = async (options: ServiceOptions): Promise<Server> => {
|
||||
let prepared: Service;
|
||||
try {
|
||||
prepared = await prepareService(options);
|
||||
} catch (error) {
|
||||
return fail(error);
|
||||
}
|
||||
|
||||
const { config, db, logger, app } = prepared;
|
||||
const server: Server = createServer(getRequestListener(app.fetch));
|
||||
|
||||
server.keepAliveTimeout = 65_000;
|
||||
server.headersTimeout = 70_000;
|
||||
|
||||
const shutdown = async (signal: string) => {
|
||||
logger.info("arret demande", { signal });
|
||||
// Le SIGTERM de docker stop a un delai limite : fermer d'abord l'ecoute
|
||||
// evite de nouvelles requetes, puis attendre les requetes en cours.
|
||||
server.close(async () => {
|
||||
await db.close().catch((error: unknown) => logger.error("fermeture base", { error: String(error) }));
|
||||
logger.info("arret termine");
|
||||
process.exit(0);
|
||||
});
|
||||
setTimeout(() => {
|
||||
logger.warn("arret force apres delai");
|
||||
process.exit(1);
|
||||
}, 10_000).unref();
|
||||
};
|
||||
|
||||
process.on("SIGTERM", () => void shutdown("SIGTERM"));
|
||||
process.on("SIGINT", () => void shutdown("SIGINT"));
|
||||
process.on("unhandledRejection", (reason) => {
|
||||
logger.error("rejet de promesse non gere", { reason: String(reason) });
|
||||
});
|
||||
|
||||
await new Promise<void>((resolve) => {
|
||||
server.listen(config.PORT, "0.0.0.0", () => resolve());
|
||||
});
|
||||
|
||||
const address = server.address() as AddressInfo;
|
||||
logger.info("api prete", {
|
||||
port: address.port,
|
||||
env: config.NODE_ENV,
|
||||
db: `${config.DB_HOST}:${config.DB_PORT}/${config.DB_NAME}`,
|
||||
});
|
||||
|
||||
return server;
|
||||
};
|
||||
|
||||
export { AppError, ConfigError, Db, createApp, createLogger, loadConfig, runMigrations };
|
||||
export type { AppOptions, Config, Logger, RouteDeps };
|
||||
Reference in New Issue
Block a user