@tricoteuses/senat 3.0.2 → 3.1.0

package/lib/src/server/loaders.js

@@ -0,0 +1,260 @@
+import fsex from "fs-extra";
+import fs from "fs";
+import path from "path";
+import * as git from "./git.js";
+import { datasets } from "./datasets.js";
+import { UNDEFINED_SESSION } from "../other_types/sessions.js";
+export { EnabledDatasets } from "./datasets.js";
+export const AGENDA_FOLDER = "agenda";
+export const COMPTES_RENDUS_FOLDER = "seances";
+export const COMMISSION_FOLDER = "commissions";
+export const DOSLEG_DOSSIERS_FOLDER = "dossiers";
+export const ENRICHED_TEXTE_FOLDER = "leg_enrichi";
+export const SCRUTINS_FOLDER = "scrutins";
+export const SENS_CIRCONSCRIPTIONS_FOLDER = "circonscriptions";
+export const SENS_ORGANISMES_FOLDER = "organismes";
+export const SENS_SENATEURS_FOLDER = "senateurs";
+export const TEXTE_FOLDER = "leg";
+export const RAPPORT_FOLDER = "rap";
+export const DATA_ORIGINAL_FOLDER = "original";
+export const DATA_TRANSFORMED_FOLDER = "transformed";
+export const DOCUMENT_METADATA_FILE = "metadata.json";
+export function* iterFilePaths(dirPath) {
+    if (dirPath && fs.existsSync(dirPath)) {
+        const files = fs.readdirSync(dirPath, {
+            withFileTypes: true,
+            recursive: true,
+        });
+        for (const file of files) {
+            if (file.isFile()) {
+                yield path.join(file.parentPath, file.name);
+            }
+        }
+    }
+}
+function* iterLoadSenatItems(dataDir, dataName, legislatureOrSession, subDir, { log = false, sinceCommit } = {}) {
+    let itemsDir = path.join(dataDir, dataName);
+    if (subDir) {
+        itemsDir = path.join(itemsDir, subDir);
+    }
+    if (legislatureOrSession) {
+        itemsDir = path.join(itemsDir, String(legislatureOrSession));
+    }
+    // Get changed files if sinceCommit is specified (excluding deleted files)
+    const changedFiles = sinceCommit
+        ? git.getChangedFilesSinceCommit(itemsDir, sinceCommit, {
+            diffFilter: "AMR", // Added, Modified, Renamed
+        })
+        : null;
+    if (log && sinceCommit) {
+        console.log(`Filtering files changed since commit ${sinceCommit} in ${itemsDir}`);
+        console.log(`Found ${changedFiles?.size || 0} changed files (AMR)`);
+    }
+    for (const filePath of iterFilePaths(itemsDir)) {
+        if (!filePath.endsWith(".json")) {
+            continue;
+        }
+        const relativePath = path.relative(path.join(dataDir, dataName), filePath);
+        const gitStatus = changedFiles?.get(relativePath);
+        // Filter by changed files if sinceCommit is specified
+        if (changedFiles && !gitStatus) {
+            // Skip files not in the change set
+            continue;
+        }
+        if (log) {
+            console.log(`Loading file: ${filePath}…${gitStatus ? ` (${gitStatus})` : ""}`);
+        }
+        let item;
+        try {
+            const itemJson = fs.readFileSync(filePath, { encoding: "utf8" });
+            item = JSON.parse(itemJson);
+        }
+        catch (error) {
+            const err = error;
+            console.warn(`[iterLoadSenatItems] skipped invalid JSON: ${filePath} (${err.message})`);
+            continue;
+        }
+        const filePathFromDataset = filePath.substring(filePath.indexOf(dataName) + dataName.length);
+        yield {
+            item,
+            filePathFromDataset,
+            legislature: legislatureOrSession,
+            ...(gitStatus && { gitStatus }), // Include gitStatus
+        };
+    }
+    // Yield deleted files at the end if sinceCommit is specified
+    if (sinceCommit) {
+        const deletedFiles = git.getChangedFilesSinceCommit(itemsDir, sinceCommit, {
+            diffFilter: "D", // Deleted
+        });
+        if (log) {
+            console.log(`Found ${deletedFiles.size || 0} deleted files (D)`);
+        }
+        for (const [relativePath, status] of deletedFiles.entries()) {
+            const deletedFilePath = path.join(itemsDir, relativePath);
+            if (log) {
+                console.log(`Deleted file: ${deletedFilePath}`);
+            }
+            // Extract UID from filename (remove extension) for the placeholder item
+            const fileExtension = path.extname(relativePath) || ".json"; // Assuming files use an extension like .json
+            const filename = path.basename(relativePath, fileExtension);
+            const fakeItem = { uid: filename }; // Placeholder item using uid constraint
+            const filePathFromDataset = deletedFilePath.substring(deletedFilePath.indexOf(dataName) + dataName.length);
+            yield {
+                item: fakeItem,
+                filePathFromDataset,
+                legislature: legislatureOrSession,
+                gitStatus: status,
+            };
+        }
+    }
+}
+export function* iterLoadSenatAmendements(dataDir, session, options = {}) {
+    for (const amendementItem of iterLoadSenatItems(dataDir, datasets.ameli.database, session, undefined, options)) {
+        yield amendementItem;
+    }
+}
+export function* iterLoadSenatDebats(dataDir, session, options = {}) {
+    for (const debatItem of iterLoadSenatItems(dataDir, datasets.debats.database, session, undefined, options)) {
+        yield debatItem;
+    }
+}
+export function* iterLoadSenatComptesRendusSeances(dataDir, session, options = {}) {
+    for (const compteRenduItem of iterLoadSenatItems(dataDir, COMPTES_RENDUS_FOLDER, session, DATA_TRANSFORMED_FOLDER, options)) {
+        yield compteRenduItem;
+    }
+}
+export function* iterLoadSenatComptesRendusCommissions(dataDir, session, options = {}) {
+    for (const compteRenduItem of iterLoadSenatItems(dataDir, COMMISSION_FOLDER, session, DATA_TRANSFORMED_FOLDER, options)) {
+        yield compteRenduItem;
+    }
+}
+export function* iterLoadSenatDossiersLegislatifs(dataDir, session, options = {}) {
+    for (const dossierLegislatifItem of iterLoadSenatItems(dataDir, datasets.dosleg.database, session, DOSLEG_DOSSIERS_FOLDER, options)) {
+        yield dossierLegislatifItem;
+    }
+}
+export function* iterLoadSenatRapportUrls(dataDir, session) {
+    let itemsDir = path.join(dataDir, RAPPORT_FOLDER, DATA_ORIGINAL_FOLDER);
+    if (session) {
+        itemsDir = path.join(itemsDir, session.toString());
+    }
+    for (const filePath of iterFilePaths(itemsDir)) {
+        const parsedFilePath = path.parse(filePath);
+        if (parsedFilePath.base === DOCUMENT_METADATA_FILE) {
+            const itemJson = fs.readFileSync(filePath, { encoding: "utf8" });
+            const item = JSON.parse(itemJson);
+            yield {
+                item,
+            };
+        }
+    }
+}
+export function* iterLoadSenatTexteUrls(dataDir, session) {
+    let itemsDir = path.join(dataDir, TEXTE_FOLDER, DATA_ORIGINAL_FOLDER);
+    if (session) {
+        itemsDir = path.join(itemsDir, session.toString());
+    }
+    for (const filePath of iterFilePaths(itemsDir)) {
+        const parsedFilePath = path.parse(filePath);
+        if (parsedFilePath.base === DOCUMENT_METADATA_FILE) {
+            const itemJson = fs.readFileSync(filePath, { encoding: "utf8" });
+            const item = JSON.parse(itemJson);
+            yield {
+                item,
+            };
+        }
+    }
+}
+export function* iterLoadSenatRapports(dataDir, session, options = {}) {
+    for (const iterItem of iterLoadSenatItems(dataDir, RAPPORT_FOLDER, session, "original", options)) {
+        if (iterItem.item?.["id"]) {
+            yield iterItem;
+        }
+    }
+}
+export function* iterLoadSenatTextes(dataDir, session, options = {}) {
+    for (const iterItem of iterLoadSenatItems(dataDir, TEXTE_FOLDER, session, DATA_ORIGINAL_FOLDER, options)) {
+        if (!iterItem.item?.["id"]) {
+            continue;
+        }
+        const texteItem = iterItem;
+        const texte = texteItem.item;
+        const texteId = texte["id"];
+        if (!texteId) {
+            continue;
+        }
+        const { item: texteContent } = loadSenatTexteContent(dataDir, texte["session"], texteId);
+        if (texteContent) {
+            texteItem.item = { ...texteContent, ...texteItem.item };
+        }
+        yield texteItem;
+    }
+}
+export function loadSenatTexteContent(dataDir, session, texteId) {
+    const fullTextePath = path.join(dataDir, TEXTE_FOLDER, DATA_TRANSFORMED_FOLDER, String(session ?? UNDEFINED_SESSION), texteId, `${texteId}.json`);
+    if (!fs.existsSync(fullTextePath)) {
+        return { item: null };
+    }
+    const texteJson = fs.readFileSync(fullTextePath, { encoding: "utf8" });
+    return { item: JSON.parse(texteJson) };
+}
+export function loadSenatCompteRenduContent(dataDir, session, debatId) {
+    const fullPath = path.join(dataDir, COMPTES_RENDUS_FOLDER, DATA_TRANSFORMED_FOLDER, String(session), `${debatId}.json`);
+    if (!fs.existsSync(fullPath)) {
+        return { item: null };
+    }
+    const json = fs.readFileSync(fullPath, { encoding: "utf8" });
+    return { item: JSON.parse(json) };
+}
+export function* iterLoadSenatAgendas(dataDir, session) {
+    const baseDir = path.join(dataDir, AGENDA_FOLDER, DATA_TRANSFORMED_FOLDER, String(session ?? ""));
+    if (!fs.existsSync(baseDir))
+        return;
+    const files = (fs.readdirSync(baseDir) || []).filter((f) => f.startsWith("RUSN") && f.endsWith(".json")).sort();
+    for (const fileName of files) {
+        const filePath = path.join(baseDir, fileName);
+        let raw;
+        try {
+            raw = fsex.readJSONSync(filePath);
+        }
+        catch {
+            continue; // JSON invalide
+        }
+        if (!raw || typeof raw !== "object")
+            continue;
+        const gr = raw;
+        if (!gr.uid || !gr.date || !gr.titre)
+            continue;
+        const reunion = {
+            ...gr,
+            events: Array.isArray(gr.events) ? gr.events : [],
+        };
+        yield { item: reunion };
+    }
+}
+export function* iterLoadSenatCirconscriptions(dataDir, options = {}) {
+    for (const circonscriptionItem of iterLoadSenatItems(dataDir, datasets.sens.database, undefined, SENS_CIRCONSCRIPTIONS_FOLDER, options)) {
+        yield circonscriptionItem;
+    }
+}
+export function* iterLoadSenatOrganismes(dataDir, options = {}) {
+    for (const organismeItem of iterLoadSenatItems(dataDir, datasets.sens.database, undefined, SENS_ORGANISMES_FOLDER, options)) {
+        yield organismeItem;
+    }
+}
+export function* iterLoadSenatSenateurs(dataDir, options = {}) {
+    for (const senateurItem of iterLoadSenatItems(dataDir, datasets.sens.database, undefined, SENS_SENATEURS_FOLDER, options)) {
+        yield senateurItem;
+    }
+}
+export function* iterLoadSenatQuestions(dataDir, legislature, options = {}) {
+    for (const questionItem of iterLoadSenatItems(dataDir, datasets.questions.database, legislature, undefined, options)) {
+        yield questionItem;
+    }
+}
+export function* iterLoadSenatScrutins(dataDir, session, options = {}) {
+    for (const scrutinItem of iterLoadSenatItems(dataDir, "scrutins", session, undefined, options)) {
+        yield scrutinItem;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { QuestionResult } from "../rich_types/questions.js";
+export declare function findAll(): AsyncGenerator<QuestionResult, void, unknown>;

package/lib/src/server/questions.js

@@ -0,0 +1,89 @@
+import { sql } from "kysely";
+import { jsonArrayFrom } from "kysely/helpers/postgres";
+import { db, streamRawQuery } from "./databases_postgres.js";
+export async function* findAll() {
+    const compiledQuery = db
+        .withSchema("senat")
+        .selectFrom("questions_tam_questions as tam_questions")
+        .leftJoin("questions_tam_ministeres as tam_ministeres", "tam_ministeres.minid", "tam_questions.mindepotid")
+        .leftJoin("questions_sortquestion as sortquestion", (join) => join.on(sql `tam_questions.sorquecod::text = sortquestion.sorquecod`))
+        .leftJoin("questions_naturequestion as naturequestion", "naturequestion.natquecod", "tam_questions.natquecod")
+        .leftJoin("questions_etatquestion as etatquestion", (join) => join.on(sql `tam_questions.etaquecod::text = etatquestion.etaquecod`))
+        .select((eb) => [
+        sql `${eb.ref("tam_questions.repub")}::text`.as("republique"),
+        sql `${eb.ref("tam_questions.legislature")}::text`.as("legislature"),
+        "tam_questions.natquecod as nature",
+        "naturequestion.natquelib as nature_libelle",
+        "tam_questions.numero as numero",
+        "tam_questions.reference as reference",
+        "tam_questions.titre as titre",
+        "tam_questions.nom as nom",
+        "tam_questions.prenom as prenom",
+        "tam_questions.nomtechnique as nom_technique",
+        "tam_questions.codequalite as civilite",
+        "tam_questions.matricule as matricule",
+        sql `${eb.ref("tam_questions.cirnum")}::text`.as("circonscription_numero"),
+        "tam_questions.circonscription as circonscription",
+        "tam_questions.groupe as groupe",
+        "tam_questions.ratgrp as type_appartenance",
+        sql `to_char(${eb.ref("tam_questions.datejodepot")}, 'YYYY-MM-DD')`.as("date_publication_JO"),
+        sql `${eb.ref("tam_questions.pagejodepot")}::text`.as("page_JO"),
+        sql `rtrim(${eb.ref("tam_questions.mindepotlib")})`.as("ministere_depot"),
+        sql `${eb.ref("tam_questions.mindepotid")}::text`.as("ministere_depot_id"),
+        sql `to_char(${eb.ref("tam_ministeres.datedebut")}, 'YYYY-MM-DD')`.as("ministere_depot_date_debut"),
+        sql `to_char(${eb.ref("tam_questions.datejotran")}, 'YYYY-MM-DD')`.as("date_transmission"),
+        "tam_questions.mintranlib as ministere_transmission",
+        sql `to_char(${eb.ref("tam_questions.datejorep1")}, 'YYYY-MM-DD')`.as("date_reponse_JO"),
+        sql `to_char(${eb.ref("tam_questions.dateerr")}, 'YYYY-MM-DD')`.as("date_erratum_JO"),
+        sql `${eb.ref("tam_questions.pageerr")}::text`.as("page_erratum_JO"),
+        "tam_questions.minreplib1 as ministere_reponse",
+        sql `to_char(${eb.ref("tam_questions.datecloture")}, 'YYYY-MM-DD')`.as("date_cloture"),
+        sql `to_char(${eb.ref("tam_questions.datesignal")}, 'YYYY-MM-DD')`.as("date_signalement"),
+        "tam_questions.refquerappelee as reference_question_rappelee",
+        "tam_questions.txtque as texte",
+        "tam_questions.txterrque as texte_erratum",
+        "tam_questions.rubrique as rubrique",
+        "sortquestion.sorquelib as sort",
+        "sortquestion.sorquecod as sort_code",
+        sql `${eb.ref("sortquestion.sorquenumtri")}::text`.as("sort_tri"),
+        "etatquestion.etaquelib as etat_libelle",
+        "etatquestion.etaquecod as etat_code",
+        sql `${eb.ref("etatquestion.etaquenumtri")}::text`.as("etat_tri"),
+        // Thèmes (extraits par regexp depuis la colonne themes)
+        sql `(
+        select coalesce(json_agg(theme_rows.libelle order by theme_rows.theme_order nulls last), '[]'::json)
+        from (
+          select
+            the.thelib as libelle,
+            the.thenouidt as theme_order
+          from regexp_matches(coalesce(${eb.ref("tam_questions.themes")}, ''), '#(\\d+)', 'g') as matches(match)
+          join senat.questions_the as the on the.thenouidt::text = matches.match[1]
+          order by the.thenouidt asc
+        ) as theme_rows
+      )`.as("themes"),
+        // Réponses
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("questions_tam_reponses as tam_reponses")
+            .select([
+            sql `to_char(tam_reponses.datejorep, 'YYYY-MM-DD')`.as("date_reponse_JO"),
+            sql `tam_reponses.pagejorep::text`.as("page_JO"),
+            sql `to_char(tam_reponses.errdate, 'YYYY-MM-DD')`.as("date_erratum_JO"),
+            "tam_reponses.minreplib as ministere_reponse",
+            sql `tam_reponses.minrepid::text`.as("ministere_reponse_id"),
+            "tam_reponses.urlrep as url",
+            "tam_reponses.txtrep as texte",
+            "tam_reponses.txterrrep as texte_erratum",
+        ])
+            .whereRef("tam_reponses.idque", "=", "tam_questions.id")
+            .orderBy("tam_reponses.datejorep", "asc")).as("reponses"),
+    ])
+        .compile();
+    for await (const row of streamRawQuery(compiledQuery)) {
+        yield {
+            ...row,
+            reponses: row.reponses ?? [],
+            themes: row.themes ?? [],
+        };
+    }
+}

package/lib/src/server/scrutins.d.ts

@@ -0,0 +1,2 @@
+import type { ScrutinResult } from "../scrutins.js";
+export declare function findAllScrutins(fromSession?: number): AsyncGenerator<ScrutinResult, void, unknown>;

package/lib/src/server/scrutins.js

@@ -0,0 +1,114 @@
+import { sql } from "kysely";
+import { jsonArrayFrom } from "kysely/helpers/postgres";
+import { db, streamRawQuery } from "./databases_postgres.js";
+export async function* findAllScrutins(fromSession) {
+    const baseQuery = db
+        .withSchema("senat")
+        .selectFrom("dosleg_scr as scr")
+        .leftJoin("dosleg_date_seance as date_seance", "date_seance.code", "scr.code")
+        .leftJoin("dosleg_lecass as lecass", "lecass.lecassidt", "date_seance.lecidt")
+        .leftJoin("dosleg_lecture as lecture", "lecture.lecidt", "lecass.lecidt")
+        .leftJoin("dosleg_loi as loi", "loi.loicod", "lecture.loicod")
+        .leftJoin("dosleg_typlec as typlec", "typlec.typleccod", "lecture.typleccod")
+        .select((eb) => [
+        sql `${eb.ref("scr.sesann")}::text`.as("session"),
+        sql `${eb.ref("scr.scrnum")}::text`.as("numero"),
+        sql `rtrim(${eb.ref("date_seance.lecidt")})`.as("lecture_id"),
+        sql `rtrim(${eb.ref("lecture.leccom")})`.as("lecture_libelle"),
+        "loi.signet as signet_dossier",
+        sql `rtrim(${eb.ref("typlec.typleclib")})`.as("type_lecture"),
+        sql `to_char(${eb.ref("scr.scrdat")}, 'YYYY-MM-DD')`.as("date_scrutin"),
+        sql `to_char(${eb.ref("scr.scrdateff")}, 'YYYY-MM-DD')`.as("date_scrutin_effective"),
+        sql `replace(${eb.ref("scr.scrint")}, E'\\u0092', '''')`.as("intitule"),
+        "scr.scrbaspag as note",
+        sql `${eb.ref("scr.scrmaj")}::text`.as("nombre_majorite"),
+        sql `${eb.ref("scr.scrmajsea")}::text`.as("nombre_majorite_seance"),
+        sql `${eb.ref("scr.scrvot")}::text`.as("nombre_votants"),
+        sql `${eb.ref("scr.scrvotsea")}::text`.as("nombre_votants_seance"),
+        sql `${eb.ref("scr.scrsuf")}::text`.as("nombre_suffrages"),
+        sql `${eb.ref("scr.scrsufsea")}::text`.as("nombre_suffrages_seance"),
+        sql `${eb.ref("scr.scrcon")}::text`.as("nombre_contre"),
+        sql `${eb.ref("scr.scrconsea")}::text`.as("nombre_contre_seance"),
+        sql `${eb.ref("scr.scrpou")}::text`.as("nombre_pour"),
+        sql `${eb.ref("scr.scrpousea")}::text`.as("nombre_pour_seance"),
+        // Votes individuels
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("dosleg_votsen as votsen")
+            .leftJoin("dosleg_titsen as titsen", "titsen.titsencod", "votsen.titsencod")
+            .leftJoin("dosleg_stavot as stavot", "stavot.stavotidt", "votsen.stavotidt")
+            .leftJoin("dosleg_posvot as posvot", "posvot.posvotcod", "votsen.posvotcod")
+            .leftJoin("sens_memgrppol as memgrppol", (join) => join
+            .onRef("memgrppol.senmat", "=", "votsen.senmat")
+            .on(sql `memgrppol.memgrppoldatdeb <= ${eb.ref("scr.scrdat")}`)
+            .on(sql `(memgrppol.memgrppoldatfin >= ${eb.ref("scr.scrdat")} or memgrppol.memgrppoldatfin is null)`))
+            .select([
+            "votsen.senmat as matricule_votant",
+            "votsen.senmatdel as matricule_delegant",
+            "posvot.posvotlib as position",
+            "stavot.stavotlib as statut_votant",
+            "titsen.titsenlib as titre_votant",
+            sql `memgrppol.memgrppolid::text`.as("groupe_politique_id"),
+            "memgrppol.grppolcod as groupe_politique_code",
+            "memgrppol.memgrppoldatdeb as membership_start",
+        ])
+            .whereRef("votsen.scrnum", "=", "scr.scrnum")
+            .whereRef("votsen.sesann", "=", "scr.sesann")
+            .orderBy("memgrppol.memgrppoldatdeb", (ob) => ob.desc().nullsLast())).as("votes"),
+        // Groupes votants (avec déduplication via window function)
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom(eb
+            .withSchema("senat")
+            .selectFrom("dosleg_votsen as votsen")
+            .leftJoin("dosleg_posvot as posvot", "posvot.posvotcod", "votsen.posvotcod")
+            .leftJoin("dosleg_stavot as stavot", "stavot.stavotidt", "votsen.stavotidt")
+            .leftJoin("sens_memgrppol as memgrppol", (join) => join
+            .onRef("memgrppol.senmat", "=", "votsen.senmat")
+            .on(sql `memgrppol.memgrppoldatdeb <= ${eb.ref("scr.scrdat")}`)
+            .on(sql `(memgrppol.memgrppoldatfin >= ${eb.ref("scr.scrdat")} or memgrppol.memgrppoldatfin is null)`))
+            .select([
+            "votsen.senmat",
+            "posvot.posvotlib",
+            "stavot.stavotlib",
+            "memgrppol.grppolcod",
+            sql `row_number() over (
+                  partition by votsen.senmat, votsen.scrnum, votsen.sesann
+                  order by memgrppol.memgrppoldatdeb desc nulls last
+                )`.as("vote_rank"),
+        ])
+            .whereRef("votsen.scrnum", "=", "scr.scrnum")
+            .whereRef("votsen.sesann", "=", "scr.sesann")
+            .as("unique_votes"))
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            .select((_eb2) => [
+            "unique_votes.grppolcod as groupe_politique_code",
+            sql `sum(case when unique_votes.posvotlib = 'pour' then 1 else 0 end)::text`.as("nombre_pour"),
+            sql `sum(case when unique_votes.posvotlib = 'contre' then 1 else 0 end)::text`.as("nombre_contre"),
+            sql `sum(case when unique_votes.posvotlib = 'abstention' then 1 else 0 end)::text`.as("nombre_abstentions"),
+            sql `sum(case when unique_votes.posvotlib = 'non-votant' then 1 else 0 end)::text`.as("nombre_non_votants"),
+            sql `count(unique_votes.senmat)::text`.as("nombre_votants"),
+        ])
+            .where("unique_votes.vote_rank", "=", 1)
+            .groupBy("unique_votes.grppolcod")).as("groupes_votants"),
+        // Mises au point (corrections)
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("dosleg_corscr as corscr")
+            .select([
+            "corscr.corscrtxt as texte",
+            sql `corscr.corscrord::text`.as("ordre"),
+            "corscr.corscrurl as url",
+        ])
+            .whereRef("corscr.scrnum", "=", "scr.scrnum")).as("mises_au_point"),
+    ]);
+    const compiledQuery = (fromSession === undefined ? baseQuery : baseQuery.where("scr.sesann", ">=", String(fromSession))).compile();
+    for await (const row of streamRawQuery(compiledQuery)) {
+        yield {
+            ...row,
+            groupes_votants: row.groupes_votants ?? [],
+            mises_au_point: row.mises_au_point ?? [],
+            votes: row.votes ?? [],
+        };
+    }
+}

package/lib/src/server/seance.d.ts

@@ -0,0 +1,3 @@
+import { CompteRendu } from "../other_types/compte_rendu.js";
+export declare function parseCompteRenduIntervalFromFile(xmlFilePath: string, startIndex: number, endIndex: number, agendaEventId: string): Promise<CompteRendu | null>;
+export declare function sessionStartYearFromDate(d: Date): number;