feat: init repo
deploy / deploy (push) Canceled after 0s

This commit is contained in:
2026-11-10 19:56:03 +01:00
commit 858d862fed
166 changed files with 13336 additions and 0 deletions
+224
View File
@@ -0,0 +1,224 @@
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, et le CRM n'a pas de notion de
* quota. 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;
};
+137
View File
@@ -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 };
+95
View File
@@ -0,0 +1,95 @@
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),
PUBLIC_ORIGIN: z.url().optional().transform((v) => v ?? null),
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),
});
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}`;
});
+107
View File
@@ -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();
}
}
+100
View File
@@ -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 tooManyRequests(message = "Trop de requetes. Reessayez plus tard.") {
return new AppError(429, "TOO_MANY_REQUESTS", message);
}
static serviceUnavailable(message = "Service momentanement indisponible.") {
return new AppError(503, "UNAVAILABLE", 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." };
}
};
+154
View File
@@ -0,0 +1,154 @@
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>;
/** 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 };
+47
View File
@@ -0,0 +1,47 @@
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,
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 {
prepareService,
startService,
type Service,
type ServiceOptions,
} from "./service.js";
+144
View File
@@ -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.",
);
};
+135
View File
@@ -0,0 +1,135 @@
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;
}
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),
});
}
}
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 };