chore: initial import of CoHaiSe Cloud
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.
This commit is contained in:
2026-10-14 15:24:06 +02:00
commit cc397e96d8
113 changed files with 12678 additions and 0 deletions
+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.",
);
};