@@ -0,0 +1,33 @@
|
||||
{
|
||||
"name": "@cohaise/server",
|
||||
"version": "0.0.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./dist/index.d.ts",
|
||||
"default": "./dist/index.js"
|
||||
}
|
||||
},
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"scripts": {
|
||||
"build": "tsc --build",
|
||||
"clean": "node --eval \"import('node:fs').then(fs => { fs.rmSync('dist', { recursive: true, force: true }); fs.rmSync('tsconfig.tsbuildinfo', { force: true }); })\"",
|
||||
"typecheck": "tsc --noEmit"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^24.0.0",
|
||||
"typescript": "^7.0.2"
|
||||
},
|
||||
"dependencies": {
|
||||
"@hono/node-server": "^2.1.3",
|
||||
"hono": "^4.13.13",
|
||||
"mysql2": "^3.24.5",
|
||||
"zod": "^4.6.5"
|
||||
},
|
||||
"bin": {
|
||||
"cohaise-migrate": "./dist/cli.js"
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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,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}`;
|
||||
});
|
||||
@@ -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 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." };
|
||||
}
|
||||
};
|
||||
@@ -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 };
|
||||
@@ -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";
|
||||
@@ -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,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 };
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"$schema": "https://json.schemastore.org/tsconfig",
|
||||
"extends": "../../tsconfig.base.json",
|
||||
"compilerOptions": {
|
||||
"module": "NodeNext",
|
||||
"moduleResolution": "NodeNext",
|
||||
"lib": ["ES2023"],
|
||||
"types": ["node"],
|
||||
"rootDir": "src",
|
||||
"outDir": "dist",
|
||||
"composite": true,
|
||||
"declaration": true,
|
||||
"declarationMap": true,
|
||||
"sourceMap": true
|
||||
},
|
||||
"include": ["src/**/*.ts"]
|
||||
}
|
||||
Reference in New Issue
Block a user