fix(admin): split getMultiYearGapTrend global mode to avoid GROUP BY literal

Postgres rejects string constants in `GROUP BY` ("non-integer constant
in GROUP BY"). The previous implementation pushed `'Global'` as a
literal segment expression through the shared code path, which made
the query fail at runtime even though the Drizzle-mocked unit tests
passed.

Split the global mode into its own query branch: group by year only,
attach the hardcoded `'Global'` series label in TypeScript. Workforce
and NAF modes keep the CASE-based segment expression — those are real
expressions, which Postgres happily accepts in GROUP BY.

No behaviour change for consumers; fixes the empty chart observed in
K10 E2E tests on CI (`<figure>` never rendered because the procedure
threw 500s that the client rendered as "Aucune donnée").

Author: LucasCharrier

packages/app/src/server/api/routers/adminStats.ts

@@ -198,27 +198,55 @@ export const adminStatsRouter = createTRPCRouter({
 				filters.push(isNotNull(companies.nafCode));
 			}
 
-			const segmentExpr = buildSegmentExpression(input.segmentBy);
-
-			const needsCompaniesJoin =
-				input.segmentBy !== "global" ||
-				shouldApplySizeRange ||
-				shouldApplyNafFilter;
-
-			const baseQuery = ctx.db.select({
-				year: declarations.year,
-				segment: segmentExpr,
-				avgGap: sql<string | null>`avg(${declarations.averageGap})`,
-				sampleSize: sql<number>`count(*)::int`,
-			});
-
-			const scoped = needsCompaniesJoin
-				? baseQuery
-						.from(declarations)
-						.innerJoin(companies, eq(declarations.siren, companies.siren))
-				: baseQuery.from(declarations);
+			// Global mode collapses every row into a single series, so we group
+			// by year only. A literal segment expression can't live in `GROUP BY`
+			// — Postgres rejects string constants there ("non-integer constant
+			// in GROUP BY"). The `'Global'` label is attached back in TS.
+			if (input.segmentBy === "global") {
+				const baseQuery = ctx.db.select({
+					year: declarations.year,
+					avgGap: sql<string | null>`avg(${declarations.averageGap})`,
+					sampleSize: sql<number>`count(*)::int`,
+				});
+				const scoped =
+					shouldApplySizeRange || shouldApplyNafFilter
+						? baseQuery
+								.from(declarations)
+								.innerJoin(companies, eq(declarations.siren, companies.siren))
+						: baseQuery.from(declarations);
+				const rows = await scoped
+					.where(and(...filters))
+					.groupBy(declarations.year)
+					.orderBy(declarations.year);
+				if (rows.length === 0) return [];
+				return [
+					{
+						segment: "Global",
+						points: rows.map((row) => ({
+							year: row.year,
+							avgGap:
+								row.avgGap === null
+									? null
+									: Math.round(Number.parseFloat(row.avgGap) * 10) / 10,
+							sampleSize: row.sampleSize,
+						})),
+					},
+				];
+			}
 
-			const rows = await scoped
+			// Workforce / NAF modes: the segment column is a CASE expression
+			// (a real expression, not a constant), so Postgres is happy to see
+			// it in both SELECT and GROUP BY.
+			const segmentExpr = buildSegmentExpression(input.segmentBy);
+			const rows = await ctx.db
+				.select({
+					year: declarations.year,
+					segment: segmentExpr,
+					avgGap: sql<string | null>`avg(${declarations.averageGap})`,
+					sampleSize: sql<number>`count(*)::int`,
+				})
+				.from(declarations)
+				.innerJoin(companies, eq(declarations.siren, companies.siren))
 				.where(and(...filters))
 				.groupBy(declarations.year, segmentExpr)
 				.orderBy(declarations.year, segmentExpr);
@@ -227,12 +255,7 @@ export const adminStatsRouter = createTRPCRouter({
 		}),
 });
 
-function buildSegmentExpression(
-	segmentBy: "global" | "workforce" | "naf",
-): SQL<string> {
-	if (segmentBy === "global") {
-		return sql<string>`'Global'`;
-	}
+function buildSegmentExpression(segmentBy: "workforce" | "naf"): SQL<string> {
 	if (segmentBy === "workforce") {
 		// Mirrors the boundaries of `COMPANY_SIZE_RANGES`. Hard-coding the
 		// buckets as literals keeps the generated SQL self-documenting; if a