@tricoteuses/senat 2.23.0 → 3.0.0

package/lib/src/scripts/retrieve_open_data.js

@@ -1,7 +1,9 @@
 import assert from "assert";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
+import { formatWithPrettier, makePgTsGenerator, markAsGenerated, processDatabase } from "kanel";
+import { makeGenerateZodSchemas } from "kanel-zod";
 import path from "path";
 import StreamZip from "node-stream-zip";
 import readline from "readline";
@@ -12,7 +14,7 @@ import config from "../config";
 import { getChosenDatasets, getEnabledDatasets } from "../datasets";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers";
 import { buildIncrementalDatasetImportSql, buildNormalizeStagingSchemaSql } from "./shared/incremental_import_sql";
-import { normalizeGeneratedDefinition, prefixedName, senatSchemaName, stagingSchemaName, } from "./shared/prefixed_tables";
+import { buildGeneratedTableManifest, getGeneratedDefinitionPath, getGeneratedTableManifestPath, prefixedName, rawTypesDir, senatSchemaName, stagingSchemaName, stripDatasetPrefix, } from "./shared/prefixed_tables";
 import { buildEnsureSchemaVersionTableSql, buildIncrementSchemaVersionSql, buildSchemaStructureFingerprintQuery, } from "./shared/schema_version";
 import { buildExportStagingMetadataStatementsQuery } from "./shared/staging_metadata_sql";
 import { isCopyFromStdinLine, rewriteLineForStagingImport } from "./shared/staging_import";
@@ -27,7 +29,7 @@ const optionsDefinitions = [
     },
     {
         alias: "c",
-        help: "create TypeScript interfaces from database schemas into src/raw_types_* directories",
+        help: "create TypeScript interfaces and Zod schemas from database tables into src/raw_types",
         name: "schema",
         type: Boolean,
     },
@@ -73,9 +75,6 @@ const stagingServerName = "staging_server";
 function isIncrementalImport(options) {
     return options["incremental"] === true;
 }
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
 function connectionEnv(connection) {
     return {
         ...process.env,
@@ -124,7 +123,8 @@ async function runWithRetry(operation, options, retryOptions) {
                 throw error;
             }
             if (!options["silent"]) {
-                console.warn(`${retryOptions.label} hit a transient PostgreSQL lock error on attempt ${attempt}/${retryOptions.attempts}; retrying in ${delayMs}ms...`);
+                console.warn(`${retryOptions.label} hit a transient PostgreSQL lock error ` +
+                    `on attempt ${attempt}/${retryOptions.attempts}; retrying in ${delayMs}ms...`);
             }
             await sleep(delayMs);
             attempt += 1;
@@ -132,18 +132,30 @@ async function runWithRetry(operation, options, retryOptions) {
         }
     }
 }
-function buildPsqlCommand(baseArgs, connection, options) {
-    const sudoPrefix = options["sudo"] ? `sudo -u ${options["sudo"]} ` : "";
-    return (`${sudoPrefix}psql --quiet ` +
-        `-h ${shellQuote(connection.host)} ` +
-        `-p ${shellQuote(String(connection.port))} ` +
-        `-U ${shellQuote(connection.user)} ` +
-        `-d ${shellQuote(connection.name)} ` +
-        baseArgs);
+function buildPsqlInvocation(baseArgs, connection, options) {
+    const psqlArgs = [
+        "--quiet",
+        "-h",
+        connection.host,
+        "-p",
+        String(connection.port),
+        "-U",
+        connection.user,
+        "-d",
+        connection.name,
+        ...baseArgs,
+    ];
+    if (!options["sudo"]) {
+        return { command: "psql", args: psqlArgs };
+    }
+    return {
+        command: "sudo",
+        args: ["-u", options["sudo"], "psql", ...psqlArgs],
+    };
 }
 function runPsqlFile(sqlFilePath, dataDir, options, connection, stopOnError = true) {
-    const onErrorFlag = stopOnError ? "-v ON_ERROR_STOP=1 " : "";
-    execSync(buildPsqlCommand(`${onErrorFlag}-f ${shellQuote(sqlFilePath)}`, connection, options), {
+    const { command, args } = buildPsqlInvocation([...(stopOnError ? ["-v", "ON_ERROR_STOP=1"] : []), "-f", sqlFilePath], connection, options);
+    execFileSync(command, args, {
         cwd: dataDir,
         env: connectionEnv(connection),
         encoding: "utf-8",
@@ -151,8 +163,9 @@ function runPsqlFile(sqlFilePath, dataDir, options, connection, stopOnError = tr
     });
 }
 function runPsqlCommand(command, dataDir, options, connection, stopOnError = true) {
-    const onErrorFlag = stopOnError ? "-v ON_ERROR_STOP=1 " : "";
-    execSync(buildPsqlCommand(`${onErrorFlag}-c ${shellQuote(command)}`, connection, options), {
+    const psqlCommand = command;
+    const { command: binary, args } = buildPsqlInvocation([...(stopOnError ? ["-v", "ON_ERROR_STOP=1"] : []), "-c", psqlCommand], connection, options);
+    execFileSync(binary, args, {
         cwd: dataDir,
         env: connectionEnv(connection),
         encoding: "utf-8",
@@ -160,8 +173,9 @@ function runPsqlCommand(command, dataDir, options, connection, stopOnError = tru
     });
 }
 function runPsqlQuery(command, dataDir, options, connection, stopOnError = true) {
-    const onErrorFlag = stopOnError ? "-v ON_ERROR_STOP=1 " : "";
-    return execSync(buildPsqlCommand(`${onErrorFlag}-At -c ${shellQuote(command)}`, connection, options), {
+    const psqlCommand = command;
+    const { command: binary, args } = buildPsqlInvocation([...(stopOnError ? ["-v", "ON_ERROR_STOP=1"] : []), "-At", "-c", psqlCommand], connection, options);
+    return execFileSync(binary, args, {
         cwd: dataDir,
         env: connectionEnv(connection),
         encoding: "utf-8",
@@ -171,7 +185,8 @@ function runPsqlQuery(command, dataDir, options, connection, stopOnError = true)
 function ensureStagingSchemaHasTables(dataset, dataDir, options, connection) {
     const stagingSchema = stagingSchemaName(dataset.database);
     const tableCount = Number.parseInt(runPsqlQuery(`SELECT count(*) FROM pg_tables WHERE schemaname = '${escapeSqlLiteral(stagingSchema)}'`, dataDir, options, connection).trim(), 10);
-    assert(tableCount > 0, `Staging schema ${stagingSchema} is empty after importing ${dataset.database}. Aborting incremental merge to protect ${senatSchemaName}.`);
+    assert(tableCount > 0, `Staging schema ${stagingSchema} is empty after importing ${dataset.database}. ` +
+        `Aborting incremental merge to protect ${senatSchemaName}.`);
 }
 function ensureStagingDatabase(dataDir, options, runtime) {
     const maintenanceDb = process.env["PGDATABASE"] || "postgres";
@@ -207,16 +222,27 @@ function ensureDatabaseExists(connection, dataDir, options) {
     runPsqlCommand(`CREATE DATABASE ${connection.name} WITH OWNER ${connection.user}`, dataDir, options, maintenanceConnection);
 }
 function ensureForeignStagingServer(dataDir, options, runtime) {
-    runPsqlCommand(`CREATE EXTENSION IF NOT EXISTS postgres_fdw`, dataDir, options, runtime.target);
+    runPsqlCommand("CREATE EXTENSION IF NOT EXISTS postgres_fdw", dataDir, options, runtime.target);
     runPsqlCommand(`DROP SERVER IF EXISTS ${stagingServerName} CASCADE`, dataDir, options, runtime.target, false);
     runPsqlCommand([
         `CREATE SERVER ${stagingServerName}`,
-        `FOREIGN DATA WRAPPER postgres_fdw`,
-        `OPTIONS (host '${escapeSqlLiteral(runtime.staging.host)}', dbname '${escapeSqlLiteral(runtime.staging.name)}', port '${escapeSqlLiteral(String(runtime.staging.port))}')`,
+        "FOREIGN DATA WRAPPER postgres_fdw",
+        [
+            "OPTIONS (",
+            `host '${escapeSqlLiteral(runtime.staging.host)}', `,
+            `dbname '${escapeSqlLiteral(runtime.staging.name)}', `,
+            `port '${escapeSqlLiteral(String(runtime.staging.port))}'`,
+            ")",
+        ].join(""),
     ].join(" "), dataDir, options, runtime.target);
     runPsqlCommand([
         `CREATE USER MAPPING FOR CURRENT_USER SERVER ${stagingServerName}`,
-        `OPTIONS (user '${escapeSqlLiteral(runtime.staging.user)}', password '${escapeSqlLiteral(runtime.staging.password)}')`,
+        [
+            "OPTIONS (",
+            `user '${escapeSqlLiteral(runtime.staging.user)}', `,
+            `password '${escapeSqlLiteral(runtime.staging.password)}'`,
+            ")",
+        ].join(""),
     ].join(" "), dataDir, options, runtime.target);
 }
 function cleanupForeignStagingServer(dataDir, options, runtime) {
@@ -224,7 +250,7 @@ function cleanupForeignStagingServer(dataDir, options, runtime) {
 }
 function mountForeignStagingSchema(dataset, dataDir, options, runtime) {
     const stagingSchema = stagingSchemaName(dataset.database);
-    const importForeignSchemaCommand = `IMPORT FOREIGN SCHEMA ${stagingSchema} FROM SERVER ${stagingServerName} INTO ${stagingSchema}`;
+    const importForeignSchemaCommand = `IMPORT FOREIGN SCHEMA ${stagingSchema} ` + `FROM SERVER ${stagingServerName} INTO ${stagingSchema}`;
     runPsqlCommand(`DROP SCHEMA IF EXISTS ${stagingSchema} CASCADE`, dataDir, options, runtime.target, false);
     runPsqlCommand(`CREATE SCHEMA ${stagingSchema}`, dataDir, options, runtime.target);
     try {
@@ -342,6 +368,97 @@ function listPrefixedTables(dataset, dataDir, options, runtime) {
         .map((tableName) => tableName.trim())
         .filter((tableName) => tableName.length > 0);
 }
+function toPascalCase(text) {
+    return text.replace(/(^|_)([a-z0-9])/gi, (_match, _separator, letter) => letter.toUpperCase());
+}
+function toIdentifierName(tableName, columnName) {
+    return `${toPascalCase(tableName)}${toPascalCase(columnName)}`;
+}
+function trimComment(comment) {
+    const trimmed = comment?.trim();
+    return trimmed ? trimmed : undefined;
+}
+async function generateRawTypes(dataset, runtime, prefixedTables) {
+    await fs.ensureDir(rawTypesDir);
+    const definitionFilePath = getGeneratedDefinitionPath(dataset.database);
+    const manifestFilePath = getGeneratedTableManifestPath(dataset.database);
+    const datasetPrefix = `${dataset.database}_`;
+    const datasetOutputPath = path.join(rawTypesDir, dataset.database);
+    const generateZodSchemas = makeGenerateZodSchemas({
+        castToSchema: true,
+        getZodIdentifierMetadata: (column, details) => ({
+            name: `${toIdentifierName(stripDatasetPrefix(details.name, dataset.database), column.name)}Schema`,
+        }),
+        getZodSchemaMetadata: (details, generateFor) => {
+            const baseName = toPascalCase(stripDatasetPrefix(details.name, dataset.database));
+            const suffix = generateFor === "selector" || generateFor === undefined ? "" : toPascalCase(generateFor);
+            return {
+                name: `${baseName}${suffix}Schema`,
+                path: datasetOutputPath,
+            };
+        },
+    });
+    await fs.remove(definitionFilePath);
+    await fs.remove(manifestFilePath);
+    await processDatabase({
+        connection: {
+            database: runtime.target.name,
+            host: runtime.target.host,
+            password: runtime.target.password,
+            port: runtime.target.port,
+            user: runtime.target.user,
+        },
+        filter: (pgType) => pgType.schemaName === senatSchemaName && pgType.name.startsWith(datasetPrefix),
+        generators: [
+            makePgTsGenerator({
+                filter: (pgType) => pgType.schemaName === senatSchemaName && pgType.name.startsWith(datasetPrefix),
+                generateIdentifierType: (column, details, builtinType) => {
+                    const tableName = stripDatasetPrefix(details.name, dataset.database);
+                    return {
+                        ...builtinType,
+                        comment: undefined,
+                        name: toIdentifierName(tableName, column.name),
+                        typeDefinition: builtinType.typeDefinition.map((typeDefinition) => typeDefinition.replace(/ & \{ __flavor\?: '[^']+' \}/g, "").replace(/ & \{ __brand: '[^']+' \}/g, "")),
+                    };
+                },
+                getMetadata: (details, generateFor, builtinMetadata) => {
+                    const baseName = toPascalCase(stripDatasetPrefix(details.name, dataset.database));
+                    const suffix = generateFor === "selector" || generateFor === undefined ? "" : toPascalCase(generateFor);
+                    const tableComment = trimComment(details.comment);
+                    return {
+                        ...builtinMetadata,
+                        comment: tableComment ? [tableComment] : undefined,
+                        exportAs: "named",
+                        name: `${baseName}${suffix}`,
+                        path: datasetOutputPath,
+                    };
+                },
+                getPropertyMetadata: (property, _details, generateFor, builtinMetadata) => {
+                    const comment = trimComment(property.comment);
+                    const defaultComment = generateFor === "initializer" && property.defaultValue !== null && property.defaultValue !== undefined
+                        ? `Default value: ${property.defaultValue}`
+                        : undefined;
+                    const comments = [comment, defaultComment].filter((value) => value !== undefined);
+                    return {
+                        ...builtinMetadata,
+                        comment: comments.length > 0 ? comments : undefined,
+                    };
+                },
+                preRenderHooks: [generateZodSchemas],
+            }),
+        ],
+        outputPath: rawTypesDir,
+        postRenderHooks: [markAsGenerated, formatWithPrettier],
+        schemaNames: [senatSchemaName],
+        typescriptConfig: {
+            enumStyle: "literal-union",
+            tsModuleFormat: "esm",
+        },
+    });
+    const generatedDefinition = await fs.readFile(definitionFilePath, { encoding: "utf8" });
+    await fs.writeFile(definitionFilePath, generatedDefinition.replace(/\r\n/g, "\n"));
+    await fs.writeFile(manifestFilePath, buildGeneratedTableManifest(dataset.database, prefixedTables));
+}
 async function downloadFile(url, dest) {
     const response = await fetch(url);
     if (!response.ok) {
@@ -474,7 +591,7 @@ async function retrieveDataset(dataDir, dataset, options, runtime) {
         repairedSqlWriter.end();
         await fs.move(repairedSqlFilePath, sqlFilePath, { overwrite: true });
     }
-    if (options["all"] || options["import"] || options["schema"]) {
+    if (options["all"] || options["import"]) {
         if (!options["silent"]) {
             console.log(`Merging ${dataset.title}: ${sqlFilename} into ${runtime.target.name}.${senatSchemaName}...`);
         }
@@ -485,24 +602,13 @@ async function retrieveDataset(dataDir, dataset, options, runtime) {
         }
     }
     if (options["schema"]) {
-        const definitionsDir = path.resolve("src", "raw_types_schemats");
-        assert(fs.statSync(definitionsDir).isDirectory());
+        await fs.ensureDir(rawTypesDir);
         if (!options["silent"]) {
             console.log(`Creating TypeScript definitions from prefixed ${senatSchemaName} tables ` +
                 `for '${dataset.database}' in database '${runtime.target.name}'...`);
         }
-        const dbConnectionString = `postgres://${runtime.target.user}:${runtime.target.password}` +
-            `@${runtime.target.host}:${runtime.target.port}/${runtime.target.name}`;
-        const definitionFilePath = path.join(definitionsDir, `${dataset.database}.ts`);
-        const tables = listPrefixedTables(dataset, dataDir, options, runtime);
-        const tableOptions = tables.map((tableName) => `-t ${tableName}`).join(" ");
-        execSync(`npx schemats generate -c ${dbConnectionString} -s ${senatSchemaName} ${tableOptions} -o ${definitionFilePath}`, {
-            env: process.env,
-            encoding: "utf-8",
-        });
-        const definition = fs.readFileSync(definitionFilePath, { encoding: "utf8" });
-        const definitionRepaired = normalizeGeneratedDefinition(definition, dataset.database);
-        fs.writeFileSync(definitionFilePath, definitionRepaired);
+        const prefixedTables = listPrefixedTables(dataset, dataDir, options, runtime);
+        await generateRawTypes(dataset, runtime, prefixedTables);
     }
 }
 function buildRuntimeContext() {

package/lib/src/scripts/shared/prefixed_tables.d.ts

@@ -1,7 +1,10 @@
 export declare const senatSchemaName = "senat";
+export declare const rawTypesDir: string;
 export declare function prefixedName(datasetName: string, relationName: string): string;
 export declare function stagingSchemaName(datasetName: string): string;
 export declare function escapeRegExp(text: string): string;
-export declare function normalizeGeneratedDefinition(definition: string, datasetName: string): string;
-export declare function extractTableNamesFromGeneratedDefinition(definition: string): string[];
-export declare function extractPrefixedTableNamesFromGeneratedDefinition(definition: string, datasetName: string): string[];
+export declare function stripDatasetPrefix(relationName: string, datasetName: string): string;
+export declare function getGeneratedDefinitionPath(datasetName: string): string;
+export declare function getGeneratedTableManifestPath(datasetName: string): string;
+export declare function buildGeneratedTableManifest(datasetName: string, prefixedTables: string[]): string;
+export declare function extractPrefixedTableNamesFromGeneratedManifest(manifest: string, datasetName: string): string[];

package/lib/src/scripts/shared/prefixed_tables.js

@@ -1,4 +1,6 @@
+import path from "path";
 export const senatSchemaName = "senat";
+export const rawTypesDir = path.resolve("src", "raw_types");
 export function prefixedName(datasetName, relationName) {
     return `${datasetName}_${relationName}`;
 }
@@ -8,23 +10,27 @@ export function stagingSchemaName(datasetName) {
 export function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-export function normalizeGeneratedDefinition(definition, datasetName) {
+export function stripDatasetPrefix(relationName, datasetName) {
     const datasetPrefix = `${datasetName}_`;
-    return definition
-        .replace(/\r\n/g, "\n")
-        .replace(/AUTO-GENERATED FILE @ \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/, "AUTO-GENERATED FILE")
-        .replace(new RegExp(`\\b${escapeRegExp(datasetPrefix)}([A-Za-z0-9_]+Fields)\\b`, "g"), "$1")
-        .replace(new RegExp(`\\b${escapeRegExp(datasetPrefix)}([A-Za-z0-9_]+)\\b`, "g"), "$1");
-}
-export function extractTableNamesFromGeneratedDefinition(definition) {
-    const flattenedDefinition = definition.replace(/\n \*/g, " ");
-    const match = flattenedDefinition.match(/\$ schemats generate .*?((?: -t [^ ]+)+) -s [^\s]+/s);
-    if (!match) {
+    return relationName.startsWith(datasetPrefix) ? relationName.slice(datasetPrefix.length) : relationName;
+}
+export function getGeneratedDefinitionPath(datasetName) {
+    return path.join(rawTypesDir, `${datasetName}.ts`);
+}
+export function getGeneratedTableManifestPath(datasetName) {
+    return path.join(rawTypesDir, `${datasetName}.tables.json`);
+}
+export function buildGeneratedTableManifest(datasetName, prefixedTables) {
+    const manifest = {
+        dataset: datasetName,
+        prefixedTables: [...new Set(prefixedTables)],
+    };
+    return JSON.stringify(manifest, null, 2) + "\n";
+}
+export function extractPrefixedTableNamesFromGeneratedManifest(manifest, datasetName) {
+    const parsed = JSON.parse(manifest);
+    if (parsed.dataset !== datasetName || !Array.isArray(parsed.prefixedTables)) {
         return [];
     }
-    const tables = Array.from(match[1].matchAll(/-t ([^ ]+)/g), ([, tableName]) => tableName);
-    return [...new Set(tables)];
-}
-export function extractPrefixedTableNamesFromGeneratedDefinition(definition, datasetName) {
-    return extractTableNamesFromGeneratedDefinition(definition).map((tableName) => prefixedName(datasetName, tableName));
+    return [...new Set(parsed.prefixedTables.filter((tableName) => typeof tableName === "string"))];
 }

package/lib/src/scripts/validate_prefixed_tables.js

@@ -1,10 +1,9 @@
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
-import path from "path";
 import { sql } from "../databases_postgres";
 import { getChosenDatasets, getEnabledDatasets } from "../datasets";
 import { categoriesOption, silentOption } from "./shared/cli_helpers";
-import { extractPrefixedTableNamesFromGeneratedDefinition, senatSchemaName } from "./shared/prefixed_tables";
+import { extractPrefixedTableNamesFromGeneratedManifest, getGeneratedTableManifestPath, senatSchemaName, } from "./shared/prefixed_tables";
 const optionsDefinitions = [categoriesOption, silentOption];
 const options = commandLineArgs(optionsDefinitions);
 async function listPrefixedSenatTables(dataset) {
@@ -19,12 +18,12 @@ async function listPrefixedSenatTables(dataset) {
     return rows.map(({ relation_name }) => relation_name);
 }
 function getGeneratedDefinitionPath(dataset) {
-    return path.resolve("src", "raw_types_schemats", `${dataset.database}.ts`);
+    return getGeneratedTableManifestPath(dataset.database);
 }
 function listExpectedPrefixedSenatTables(dataset) {
-    const definitionFilePath = getGeneratedDefinitionPath(dataset);
-    const definition = fs.readFileSync(definitionFilePath, { encoding: "utf8" });
-    return extractPrefixedTableNamesFromGeneratedDefinition(definition, dataset.database);
+    const manifestFilePath = getGeneratedDefinitionPath(dataset);
+    const manifest = fs.readFileSync(manifestFilePath, { encoding: "utf8" });
+    return extractPrefixedTableNamesFromGeneratedManifest(manifest, dataset.database);
 }
 async function listColumns(schema, relationName) {
     const rows = await sql `

package/lib/src/types/ameli.d.ts

@@ -1,5 +1,5 @@
-import { ses as Ses, sub as Sub, subFields, txt_ameli } from "../raw_types_schemats/ameli";
-export type { Ses, Sub };
-export interface TxtAmeli extends txt_ameli {
-    subids?: subFields.id[];
+import { TxtAmeli } from "../raw_types/ameli";
+import { Sub } from "../raw_types/ameli";
+export interface TxtAmeliCustom extends TxtAmeli {
+    subids?: Sub["id"][];
 }

package/lib/src/types/debats.d.ts

@@ -1,2 +1,2 @@
-import { debats as Debat, lecassdeb as LecAssDeb } from "../raw_types_schemats/debats";
-export type { Debat, LecAssDeb };
+import { Debats, Lecassdeb } from "../raw_types/debats";
+export type { Debats as Debat, Lecassdeb as LecAssDeb };

package/lib/src/types/dosleg.d.ts

@@ -1,70 +1,70 @@
-import { txt_ameliFields } from "../raw_types_schemats/ameli";
-import { ass as Ass, aud, audFields, auteur, date_seance, date_seanceFields as dateSeanceFields, deccoc as DecCoc, denrap as DenRap, docatt, docattFields, ecr, ecrFields, etaloi as EtaLoi, lecass, lecassFields, lecassrap, lecture, lectureFields, loi, org as Org, oritxt as OriTxt, qua as Qua, rap, raporg as RapOrg, raporgFields, scr as Scr, texte, texteFields, typatt as TypAtt, typlec as TypLec, typloi as TypLoi, typtxt as TypTxt, typurl as TypUrl, typurlFields } from "../raw_types_schemats/dosleg";
-import { Debat } from "./debats";
-import { TxtAmeli } from "./ameli";
-export type { Ass, DecCoc, DenRap, EtaLoi, Org, OriTxt, Qua, RapOrg, Scr, TypAtt, TypLec, TypLoi, TypTxt, TypUrl };
-export interface Aud extends aud {
+import { Ass, Aud as AudRaw, Auteur as AuteurRaw, DateSeance as DateSeanceRaw, Deccoc, Denrap, Docatt as DocattRaw, Ecr as EcrRaw, Etaloi, Lecass as LecassRaw, Lecassrap as LecassrapRaw, Lecture as LectureRaw, Loi as LoiRaw, Org, Oritxt, Qua, Rap as RapRaw, Raporg, Scr, Texte as TexteRaw, Typatt, Typlec, Typloi, Typtxt, Typurl } from "../raw_types/dosleg";
+import { TxtAmeli } from "../raw_types/ameli";
+import { Debats } from "../raw_types/debats";
+import { TxtAmeliCustom } from "./ameli";
+export type { Deccoc as DecCoc, Denrap as DenRap, Etaloi as EtaLoi, Oritxt as OriTxt, Raporg as RapOrg, Typatt as TypAtt, Typlec as TypLec, Typloi as TypLoi, Typtxt as TypTxt, Typurl as TypUrl, };
+export interface Aud extends AudRaw {
     org?: Org;
 }
-export interface Auteur extends auteur {
+export interface Auteur extends AuteurRaw {
     qua?: Qua;
 }
-export interface DateSeance extends date_seance {
-    debat?: Debat;
+export interface DateSeance extends DateSeanceRaw {
+    debat?: Debats;
     scrids?: string[];
     scrs?: Scr[];
 }
-export interface DocAtt extends docatt {
-    rap?: Rap;
-    typatt?: TypAtt;
+export interface DocAtt extends DocattRaw {
+    rap?: RapRaw;
+    typatt?: Typatt;
 }
-export interface Ecr extends ecr {
+export interface Ecr extends EcrRaw {
     aut?: Auteur;
 }
-export interface LecAss extends lecass {
+export interface LecAss extends LecassRaw {
     ass?: Ass;
     auds?: Aud[];
-    audcles?: audFields.audcle[];
+    audcles?: AudRaw["audcle"][];
     datesSeances?: DateSeance[];
-    datesSeancesCodes?: dateSeanceFields.code[];
+    datesSeancesCodes?: DateSeanceRaw["code"][];
     debatdatseas: Date[];
     lecassraps?: LecAssRap[];
     lecassrapids?: string[];
     org?: Org;
-    texcods: texteFields.texcod[];
+    texcods: TexteRaw["texcod"][];
     textes?: Texte[];
 }
-export interface LecAssRap extends lecassrap {
-    rap?: Rap;
+export interface LecAssRap extends LecassrapRaw {
+    rap?: RapRaw;
 }
-export interface Lecture extends lecture {
-    typlec?: TypLec;
-    lecassidts?: lecassFields.lecassidt[];
+export interface Lecture extends LectureRaw {
+    typlec?: Typlec;
+    lecassidts?: LecassRaw["lecassidt"][];
     lecasss?: LecAss[];
 }
-export interface Loi extends loi {
-    deccoc?: DecCoc;
-    etaloi?: EtaLoi;
-    lecidts?: lectureFields.lecidt[];
+export interface Loi extends LoiRaw {
+    deccoc?: Deccoc;
+    etaloi?: Etaloi;
+    lecidts?: LectureRaw["lecidt"][];
     lectures?: Lecture[];
-    typloi?: TypLoi;
+    typloi?: Typloi;
 }
-export interface Rap extends rap {
-    denrap?: DenRap;
-    docattcles?: docattFields.docattcle[];
+export interface Rap extends RapRaw {
+    denrap?: Denrap;
+    docattcles?: DocattRaw["docattcle"][];
     docatts?: DocAtt[];
-    ecrnums?: ecrFields.ecrnum[];
+    ecrnums?: EcrRaw["ecrnum"][];
     ecrs?: Ecr[];
-    orgcods?: raporgFields.orgcod[];
+    orgcods?: Raporg["orgcod"][];
     orgs?: Org[];
 }
-export interface Texte extends texte {
+export interface Texte extends TexteRaw {
     ecrs?: Ecr[];
-    ecrnums?: ecrFields.ecrnum[];
-    libtypurl?: typurlFields.libtypurl;
+    ecrnums?: EcrRaw["ecrnum"][];
+    libtypurl?: Typurl["libtypurl"];
     org?: Org;
-    oritxt: OriTxt;
-    typtxt?: TypTxt;
-    txtAmeli?: TxtAmeli;
-    txtAmeliId: txt_ameliFields.id;
+    oritxt: Oritxt;
+    typtxt?: Typtxt;
+    txtAmeli?: TxtAmeliCustom;
+    txtAmeliId: TxtAmeli["id"];
 }

package/lib/src/types/questions.d.ts

@@ -1,2 +1,2 @@
-import { tam_questions as Question } from "../raw_types_schemats/questions";
-export type { Question };
+import { TamQuestions } from "../raw_types/questions";
+export type { TamQuestions as Question };

package/lib/src/types/sens.d.ts

@@ -1,5 +1,3 @@
-import { sen as Sen } from "../raw_types_schemats/sens";
-export type { Sen };
 export interface Photo {
     chemin: string;
     cheminMosaique: string;

package/lib/tests/prefixedTables.test.js

@@ -1,26 +1,19 @@
 import { describe, expect, it } from "vitest";
-import { extractPrefixedTableNamesFromGeneratedDefinition, normalizeGeneratedDefinition, prefixedName, senatSchemaName, stagingSchemaName, } from "../src/scripts/shared/prefixed_tables";
+import { buildGeneratedTableManifest, extractPrefixedTableNamesFromGeneratedManifest, prefixedName, senatSchemaName, stagingSchemaName, stripDatasetPrefix, } from "../src/scripts/shared/prefixed_tables";
 describe("prefixed table helpers", () => {
     it("builds prefixed table and staging schema names", () => {
         expect(prefixedName("dosleg", "texte")).toBe("dosleg_texte");
         expect(stagingSchemaName("questions")).toBe("questions_staging");
         expect(senatSchemaName).toBe("senat");
     });
-    it("normalizes generated definitions by removing dataset prefixes", () => {
-        const definition = "/* tslint:disable */\n/**\n * AUTO-GENERATED FILE @ 2026-03-20 16:00:00\n" +
-            " * $ schemats generate -c postgres://demo -t ameli_amd -t ameli_ses -s senat\n" +
-            " */\nexport namespace ameli_amdFields {}\nexport interface ameli_amd {}\nexport interface ameli_ses {}\n";
-        const normalized = normalizeGeneratedDefinition(definition, "ameli");
-        expect(normalized).toContain("AUTO-GENERATED FILE");
-        expect(normalized).not.toContain("AUTO-GENERATED FILE @");
-        expect(normalized).toContain("export namespace amdFields");
-        expect(normalized).toContain("export interface amd");
-        expect(normalized).toContain("export interface ses");
-        expect(normalized).not.toContain("ameli_amd");
+    it("strips the dataset prefix from generated type names", () => {
+        expect(stripDatasetPrefix("ameli_amd", "ameli")).toBe("amd");
+        expect(stripDatasetPrefix("ameli_txt_ameli", "ameli")).toBe("txt_ameli");
+        expect(stripDatasetPrefix("amd", "ameli")).toBe("amd");
     });
-    it("extracts expected prefixed public tables from generated definitions", () => {
-        const definition = "/**\n * $ schemats generate -c postgres://demo -t amd -t ses -t txt_ameli -s ameli\n */";
-        expect(extractPrefixedTableNamesFromGeneratedDefinition(definition, "ameli")).toEqual([
+    it("extracts expected prefixed public tables from generated manifests", () => {
+        const manifest = buildGeneratedTableManifest("ameli", ["ameli_amd", "ameli_ses", "ameli_txt_ameli"]);
+        expect(extractPrefixedTableNamesFromGeneratedManifest(manifest, "ameli")).toEqual([
             "ameli_amd",
             "ameli_ses",
             "ameli_txt_ameli",

package/lib/tests/validatePrefixedTables.test.js

@@ -1,12 +1,12 @@
 import { readFileSync } from "fs";
 import { describe, expect, it } from "vitest";
 import { datasets } from "../src/datasets";
-import { extractPrefixedTableNamesFromGeneratedDefinition } from "../src/scripts/shared/prefixed_tables";
+import { extractPrefixedTableNamesFromGeneratedManifest, getGeneratedTableManifestPath, } from "../src/scripts/shared/prefixed_tables";
 describe("generated raw types coverage", () => {
     it("maps each generated dataset definition to prefixed senat tables", () => {
         for (const dataset of Object.values(datasets)) {
-            const definition = readFileSync(`src/raw_types_schemats/${dataset.database}.ts`, { encoding: "utf8" });
-            const tableNames = extractPrefixedTableNamesFromGeneratedDefinition(definition, dataset.database);
+            const manifest = readFileSync(getGeneratedTableManifestPath(dataset.database), { encoding: "utf8" });
+            const tableNames = extractPrefixedTableNamesFromGeneratedManifest(manifest, dataset.database);
             expect(tableNames.length).toBeGreaterThan(0);
             expect(tableNames.every((tableName) => tableName.startsWith(`${dataset.database}_`))).toBe(true);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tricoteuses/senat",
-  "version": "2.23.0",
+  "version": "3.0.0",
   "description": "Handle French Sénat's open data",
   "keywords": [
     "France",
@@ -46,6 +46,7 @@
     "access": "public"
   },
   "scripts": {
+    "postinstall": "patch-package",
     "build": "tsc",
     "build:types": "tsc --emitDeclarationOnly",
     "data:convert_data": "tsx src/scripts/convert_data.ts",
@@ -86,7 +87,6 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@typed-code/schemats": "^5.0.1",
     "@types/cheerio": "^1.0.0",
     "@types/command-line-args": "^5.0.0",
     "@types/fs-extra": "^11.0.4",
@@ -99,6 +99,10 @@
     "cross-env": "^10.1.0",
     "eslint": "^9.39.2",
     "globals": "^17.0.0",
+    "kanel": "^4.0.1",
+    "kanel-zod": "^4.0.0",
+    "patch-package": "^8.0.1",
+    "postinstall-postinstall": "^2.1.0",
     "prettier": "^3.5.3",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",