chore(dev): seed script for admin conformity stats page

Adds `pnpm seed:conformite` (loads `.env` via Node --env-file) — 40
synthetic companies × 4 campaign years = 160 submitted declarations
with a deterministic pseudo-random `has_alert_gap` distribution that
drifts down over time (visible +/-2pt year-on-year delta) and carries a
small NAF-sector bias (K finance skewed up, M services skewed down).
`pnpm seed:conformite clean` reverses the fixture.

Helps explore the /admin/stats/conformite page locally without hand-
inserting rows in the DB.

Author: LucasCharrier

packages/app/package.json

@@ -29,7 +29,8 @@
 		"test:lighthouse": "lhci collect --url=${LIGHTHOUSE_URL:-http://localhost:3000} && lhci upload && lhci assert",
 		"typecheck": "tsc --noEmit",
 		"generate:fetch-companies": "tsx scripts/fetch-large-companies.ts",
-		"generate:mock-gip": "tsx scripts/generate-mock-gip-data.ts"
+		"generate:mock-gip": "tsx scripts/generate-mock-gip-data.ts",
+		"seed:conformite": "node --env-file=.env scripts/seed-conformite-stats.mjs"
 	},
 	"dependencies": {
 		"@aws-sdk/client-s3": "^3.1029.0",

packages/app/scripts/seed-conformite-stats.mjs

@@ -0,0 +1,245 @@
+/**
+ * Local dev seed for the K8 admin conformity stats page.
+ *
+ * Populates synthetic companies + submitted declarations across four campaign
+ * years (currentYear-3 … currentYear) so that `/admin/stats/conformite` has
+ * enough data to exercise every filter (year / workforce bucket / NAF sector)
+ * and show a plausible year-over-year delta on the KPI tile.
+ *
+ * Idempotent: each run upserts the same deterministic rows — feel free to run
+ * it repeatedly or after resetting the DB.
+ *
+ * Usage (from packages/app):
+ *   pnpm seed:conformite        # insert / refresh the fixture
+ *   pnpm seed:conformite clean  # remove the fixture
+ *
+ * Env: DATABASE_URL (or POSTGRES_* as with the other scripts in this folder).
+ */
+
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import postgres from "postgres";
+
+const SEED_DECLARANT_EMAIL = "seed-conformite@egapro.local";
+const SEED_DECLARANT_ID = "seed-conformite-declarant-0000-0000000";
+
+/** 777XXXXXX SIRENs are reserved for this fixture. */
+const SIREN_PREFIX = "777";
+/** Generates one company per (bucket × sector) combination, 5 × 8 = 40. */
+const WORKFORCE_BUCKETS = [20, 60, 120, 180, 300];
+const NAF_SAMPLE_CODES = [
+	"A01.11Z", // A — Agriculture
+	"C10.11Z", // C — Industrie manufacturière
+	"F41.10A", // F — Construction
+	"G47.11B", // G — Commerce
+	"J62.01Z", // J — Information & communication
+	"K64.19Z", // K — Activités financières et d'assurance
+	"M70.10Z", // M — Activités spécialisées
+	"Q86.10Z", // Q — Santé humaine
+];
+/**
+ * Kept in sync with `FIRST_DECLARATION_YEAR` from `~/modules/domain` — the
+ * year filter on `/admin/stats/conformite` goes from there to the current
+ * year, so we seed every slot to avoid empty tiles on older selections.
+ */
+const FIRST_SEED_YEAR = 2019;
+
+function getDatabaseUrl() {
+	if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
+	const user = encodeURIComponent(process.env.POSTGRES_USER ?? "postgres");
+	const password = process.env.POSTGRES_PASSWORD
+		? `:${encodeURIComponent(process.env.POSTGRES_PASSWORD)}`
+		: "";
+	const host = process.env.POSTGRES_HOST ?? "localhost";
+	const port = process.env.POSTGRES_PORT ?? "5438";
+	const db = process.env.POSTGRES_DB ?? "egapro";
+	return `postgresql://${user}${password}@${host}:${port}/${db}`;
+}
+
+/**
+ * Deterministic hash → [0, 1) pseudo-random, so re-runs are stable.
+ * @param {number} n
+ */
+function pseudoRandom(n) {
+	const hash = (n * 2654435761) >>> 0;
+	return hash / 2 ** 32;
+}
+
+/**
+ * Decide whether a (siren, year) pair is flagged as alert. We drift the base
+ * rate down over time so the delta badge is visible (improvement), and we add
+ * a small NAF-sector bias so the sector filter visibly changes the result.
+ *
+ * @param {number} companyIndex
+ * @param {number} yearsBeforeCurrent  0 = current year, 1 = N-1, ...
+ * @param {string} nafCode
+ */
+function shouldHaveAlertGap(companyIndex, yearsBeforeCurrent, nafCode) {
+	// Gentle downward drift: the oldest seeded year (2019) sits around 54%,
+	// the current year at ~40% — the points-delta badge between any two
+	// adjacent years should show a visible ~2pt swing.
+	const baseRate = 0.4 + 0.02 * yearsBeforeCurrent;
+	const sectorBias = nafCode.startsWith("K")
+		? 0.12
+		: nafCode.startsWith("M")
+			? -0.1
+			: 0;
+	const threshold = Math.min(0.9, Math.max(0.05, baseRate + sectorBias));
+	return pseudoRandom(companyIndex * 101 + yearsBeforeCurrent * 17) < threshold;
+}
+
+function sirenFor(index) {
+	return `${SIREN_PREFIX}${String(index).padStart(6, "0")}`;
+}
+
+function buildCompanyCatalog() {
+	/** @type {Array<{ siren: string; workforce: number; nafCode: string }>} */
+	const catalog = [];
+	let index = 1;
+	for (const workforce of WORKFORCE_BUCKETS) {
+		for (const nafCode of NAF_SAMPLE_CODES) {
+			catalog.push({ siren: sirenFor(index), workforce, nafCode });
+			index++;
+		}
+	}
+	return catalog;
+}
+
+/** @param {import("postgres").Sql} sql */
+async function ensureDeclarant(sql) {
+	await sql`
+		INSERT INTO app_user (id, email, is_admin)
+		VALUES (${SEED_DECLARANT_ID}, ${SEED_DECLARANT_EMAIL}, false)
+		ON CONFLICT (id) DO NOTHING
+	`;
+}
+
+/** @param {import("postgres").Sql} sql */
+async function seed(sql) {
+	await ensureDeclarant(sql);
+
+	const catalog = buildCompanyCatalog();
+	const currentYear = new Date().getFullYear();
+
+	let insertedCompanies = 0;
+	let insertedDeclarations = 0;
+
+	for (const { siren, workforce, nafCode } of catalog) {
+		await sql`
+			INSERT INTO app_company (siren, name, workforce, naf_code, created_at, updated_at)
+			VALUES (
+				${siren},
+				${`Seed K8 ${siren}`},
+				${workforce},
+				${nafCode},
+				NOW(),
+				NOW()
+			)
+			ON CONFLICT (siren) DO UPDATE SET
+				workforce = EXCLUDED.workforce,
+				naf_code = EXCLUDED.naf_code,
+				updated_at = NOW()
+		`;
+		insertedCompanies++;
+	}
+
+	for (let yearsBack = 0; yearsBack < CAMPAIGN_YEARS_BACK; yearsBack++) {
+		const year = currentYear - yearsBack;
+		let companyIndex = 0;
+		for (const { siren, nafCode } of catalog) {
+			companyIndex++;
+			const hasAlertGap = shouldHaveAlertGap(companyIndex, yearsBack, nafCode);
+			// Spread submissions over January-February so the rows look realistic
+			// (even though the campaign progression chart is not what we exercise
+			// here, keeping a plausible date avoids surprises elsewhere).
+			const submittedAt = new Date(
+				Date.UTC(year, 0, 15 + (companyIndex % 30), 9, 0, 0),
+			).toISOString();
+			await sql`
+				INSERT INTO app_declaration (
+					id, siren, year, declarant_id, current_step, status,
+					submitted_at, has_alert_gap, created_at, updated_at
+				)
+				VALUES (
+					gen_random_uuid(),
+					${siren},
+					${year},
+					${SEED_DECLARANT_ID},
+					6,
+					'submitted',
+					${submittedAt},
+					${hasAlertGap},
+					NOW(),
+					NOW()
+				)
+				ON CONFLICT ON CONSTRAINT declaration_siren_year_idx DO UPDATE SET
+					status = 'submitted',
+					submitted_at = EXCLUDED.submitted_at,
+					has_alert_gap = EXCLUDED.has_alert_gap,
+					updated_at = NOW()
+			`;
+			insertedDeclarations++;
+		}
+	}
+
+	return { insertedCompanies, insertedDeclarations };
+}
+
+/** @param {import("postgres").Sql} sql */
+async function clean(sql) {
+	const [{ deleted: deletedDeclarations }] = await sql`
+		WITH deleted AS (
+			DELETE FROM app_declaration WHERE siren LIKE ${`${SIREN_PREFIX}%`} RETURNING 1
+		)
+		SELECT COUNT(*)::int AS deleted FROM deleted
+	`;
+	const [{ deleted: deletedCompanies }] = await sql`
+		WITH deleted AS (
+			DELETE FROM app_company WHERE siren LIKE ${`${SIREN_PREFIX}%`} RETURNING 1
+		)
+		SELECT COUNT(*)::int AS deleted FROM deleted
+	`;
+	const [{ deleted: deletedUsers }] = await sql`
+		WITH deleted AS (
+			DELETE FROM app_user WHERE id = ${SEED_DECLARANT_ID} RETURNING 1
+		)
+		SELECT COUNT(*)::int AS deleted FROM deleted
+	`;
+	return { deletedDeclarations, deletedCompanies, deletedUsers };
+}
+
+async function main() {
+	const mode = process.argv[2] ?? "seed";
+	const sql = postgres(getDatabaseUrl(), { max: 1 });
+	try {
+		if (mode === "clean") {
+			const result = await clean(sql);
+			console.log(
+				`[seed-conformite] cleaned: ${result.deletedDeclarations} declarations, ${result.deletedCompanies} companies, ${result.deletedUsers} declarant.`,
+			);
+			return;
+		}
+		if (mode !== "seed") {
+			console.error(`Unknown mode "${mode}". Use "seed" (default) or "clean".`);
+			process.exit(2);
+		}
+		const result = await seed(sql);
+		console.log(
+			`[seed-conformite] upserted ${result.insertedCompanies} companies and ${result.insertedDeclarations} submitted declarations across ${CAMPAIGN_YEARS_BACK} campaign years.`,
+		);
+		console.log(
+			`[seed-conformite] open http://localhost:3000/admin/stats/conformite to browse the tile.`,
+		);
+	} finally {
+		await sql.end();
+	}
+}
+
+if (
+	import.meta.url === `file://${realpathSync(fileURLToPath(import.meta.url))}`
+) {
+	main().catch((error) => {
+		console.error("[seed-conformite] failed:", error);
+		process.exit(1);
+	});
+}