PR — Ouverture automatique / create-pr (push) Failing after 1s
Standalone files & media application: React/Vite frontend with the @cohaise/ui design system, Hono + MariaDB backend, nginx reverse proxy, Docker Compose stack, migrations 000-006, and project docs. Adds Gitea Actions workflows for deployment, automatic pull requests, and Renovate dependency updates.
145 lines
4.9 KiB
TypeScript
145 lines
4.9 KiB
TypeScript
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.",
|
|
);
|
|
};
|