@tricoteuses/senat 3.0.2 → 3.1.0

package/lib/src/server/seance.js

@@ -0,0 +1,267 @@
+import fs from "fs";
+import * as cheerio from "cheerio";
+import { toCRDate } from "../util.js";
+import { makeReunionUid } from "../utils/reunion_parsing.js";
+import { yyyymmddFromPath } from "../utils/date.js";
+import { decodeHtmlEntities, dedupeSpeaker, fixApostrophes, norm } from "../utils/string_cleaning.js";
+export async function parseCompteRenduIntervalFromFile(xmlFilePath, startIndex, endIndex, agendaEventId) {
+    try {
+        const raw = fs.readFileSync(xmlFilePath, "utf8");
+        const $ = cheerio.load(raw, { xml: false });
+        const metadonnees = extractMetadonnees($, xmlFilePath);
+        const order = $("body *").toArray();
+        const idx = new Map(order.map((el, i) => [el, i]));
+        const totalNodes = order.length;
+        const clampedStart = Math.max(0, Math.min(startIndex, totalNodes - 1));
+        const clampedEnd = Math.max(0, Math.min(endIndex, totalNodes - 1));
+        const intervals = [
+            {
+                start: clampedStart,
+                end: clampedEnd,
+            },
+        ];
+        metadonnees.sommaire = extractSommaireForIntervals($, idx, intervals);
+        const points = [];
+        let ordre = 0;
+        const addPoint = (p) => points.push({ ...p, ordre_absolu_seance: String(++ordre) });
+        // Interventions
+        $("div.intervenant").each((_, block) => {
+            if (!elementInAnyInterval(block, idx, intervals))
+                return;
+            const $block = $(block);
+            $block
+                .find([
+                "p[class^='titre_S']",
+                "p.mention_titre",
+                "p.intitule_titre",
+                "p.mention_chapitre",
+                "p.intitule_chapitre",
+                "p.mention_article",
+                "p.intitule_article",
+                "p.mention_section",
+                "p.intitule_section",
+            ].join(","))
+                .remove();
+            const firstP = $block.find("p").first();
+            if (!firstP || firstP.length === 0)
+                return;
+            const speakerLabelRaw = firstP.find(".orateur_nom").text() || firstP.find("a.lien_senfic").text() || "";
+            const speakerLabel = dedupeSpeaker(speakerLabelRaw);
+            const { mat, nom: nomCRI, qua: quaCRI } = readIntervenantMeta($block);
+            const qualFromSpans = extractAndRemoveLeadingQualite($, $block);
+            const qualite = norm(decodeHtmlEntities(quaCRI || "")) || qualFromSpans;
+            const canonicalName = dedupeSpeaker(nomCRI || speakerLabel);
+            const role = roleForSpeaker(speakerLabel) || roleForSpeaker(qualite) || roleForSpeaker(quaCRI || "");
+            const speechHtml = sanitizeInterventionHtml($, $block);
+            const speechText = norm(cheerio.load(speechHtml).text() || "");
+            if (!speechText)
+                return;
+            addPoint({
+                code_grammaire: "PAROLE_GENERIQUE",
+                roledebat: role,
+                orateurs: { orateur: { nom: canonicalName, id: mat || "", qualite } },
+                texte: { _: speechHtml },
+            });
+        });
+        const contenu = {
+            quantiemes: {
+                journee: metadonnees.dateSeance,
+                session: metadonnees.session,
+            },
+            point: points,
+        };
+        const yyyymmdd = yyyymmddFromPath(xmlFilePath);
+        const dateISO = `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
+        const seanceRef = makeReunionUid(dateISO, "SP", agendaEventId, null);
+        return {
+            uid: `CRSSN${yyyymmdd}E${agendaEventId}`,
+            seanceRef,
+            sessionRef: metadonnees.session,
+            metadonnees,
+            contenu,
+        };
+    }
+    catch (e) {
+        console.error(`[CRI] parseInterval error file=${xmlFilePath} interval=[${startIndex}..${endIndex}] event=${agendaEventId}:`, e);
+        return null;
+    }
+}
+export function sessionStartYearFromDate(d) {
+    // Session (1th oct N → 30 sept N+1)
+    const m = d.getMonth();
+    const y = d.getFullYear();
+    return m >= 9 ? y : y - 1;
+}
+function roleForSpeaker(labelOrQualite) {
+    const s = (labelOrQualite || "").toLowerCase();
+    if (/^(m\.|mme)?\s*(le|la)\s+pr[ée]sident(e)?\b/.test(s) || /\bpr[ée]sident[e]?\s+de\s+séance\b/.test(s))
+        return "président";
+    return "";
+}
+function readIntervenantMeta($block) {
+    const int = $block.find("cri\\:intervenant").first();
+    if (int.length)
+        return { mat: int.attr("mat") || undefined, nom: int.attr("nom") || undefined, qua: int.attr("qua") || undefined };
+    const html = $block.html() || "";
+    const m = html.match(/<!--\s*cri:intervenant\b([^>]+)-->/i);
+    if (!m)
+        return {};
+    const out = {};
+    const re = /(\w+)="([^"]*)"/g;
+    let a;
+    while ((a = re.exec(m[1])))
+        out[a[1]] = decodeHtmlEntities(a[2]);
+    return { mat: out["mat"], nom: out["nom"], qua: out["qua"] };
+}
+function extractAndRemoveLeadingQualite($, $block) {
+    const firstP = $block.find("p").first();
+    if (firstP.length === 0)
+        return "";
+    const parts = [];
+    let stop = false;
+    firstP.contents().each((_, node) => {
+        if (stop)
+            return;
+        if (node.type === "tag") {
+            const $node = $(node);
+            if ($node.hasClass("orateur_nom")) {
+                $node.remove();
+                return;
+            }
+            if ($node.hasClass("orateur_qualite")) {
+                parts.push($node.text() || "");
+                $node.remove();
+                return;
+            }
+            const t = norm($node.text() || "");
+            if (t)
+                stop = true;
+            else
+                $node.remove();
+        }
+        else if (node.type === "text") {
+            const textNode = node;
+            const t = norm(textNode.data || "");
+            if (!t || /^[:.,;–—-]+$/.test(t)) {
+                textNode.data = "";
+                return;
+            }
+            stop = true;
+        }
+    });
+    return fixApostrophes(norm(parts.join(" ")));
+}
+function sanitizeInterventionHtml($, $block) {
+    const ps = $block.find("p").toArray();
+    const cleaned = ps
+        .map((p) => {
+        const $p = $(p).clone();
+        $p.find(".orateur_nom, .orateur_qualite").remove();
+        $p.find("a").each((_, a) => {
+            const $a = $(a);
+            $a.replaceWith($a.text());
+        });
+        $p.find(".info_entre_parentheses").each((_, el) => {
+            const txt = $(el).text();
+            $(el).replaceWith($("<em/>").text(txt));
+        });
+        $p.find("span").each((_, span) => {
+            const $s = $(span);
+            if (!$s.text().trim())
+                $s.remove();
+        });
+        const inner = ($p.html() || "").trim();
+        if (!inner)
+            return null;
+        return `<p>${inner}</p>`;
+    })
+        .filter(Boolean);
+    return cleaned.join("<br/>");
+}
+function extractSommaireForIntervals($, idx, intervals) {
+    const inIv = (el) => elementInAnyInterval(el, idx, intervals);
+    const root = $("body");
+    const sommaire = { presidentSeance: { _: "" }, sommaire1: [] };
+    // (1) Présidence (tm2) — première ligne dans l’intervalle
+    const pres = root
+        .find("p.tm2")
+        .filter((_, el) => inIv(el))
+        .first();
+    if (pres.length)
+        sommaire.presidentSeance = { _: norm(pres.text()) };
+    // (2) Paras tm5 présents dans l’intervalle
+    const paras = [];
+    root.find("p.tm5").each((_, el) => {
+        if (!inIv(el))
+            return;
+        const t = norm($(el).text());
+        if (t)
+            paras.push({ _: t });
+    });
+    if (paras.length)
+        sommaire.para = paras.length === 1 ? paras[0] : paras;
+    // (3) Items de 1er niveau (tm3) présents dans l’intervalle
+    const items = [];
+    root.find("p.tm3").each((_, el) => {
+        if (!inIv(el))
+            return;
+        const $p = $(el);
+        const full = norm($p.text() || "");
+        if (!full)
+            return;
+        const numMatch = full.match(/^(\d+)\s*[.\-–—]\s*/);
+        const valeur = numMatch ? numMatch[1] : undefined;
+        // prefere intitule in ancre <a> if present
+        const a = $p.find("a").first();
+        const intituleRaw = a.length ? a.text() : full.replace(/^(\d+)\s*[.\-–—]\s*/, "");
+        const intitule = norm(intituleRaw);
+        // id_syceron from href="#Niv1_SOMx"
+        const href = (a.attr("href") || "").trim();
+        const idSyceron = href.startsWith("#") ? href.slice(1) : href;
+        const titreStruct = { id_syceron: idSyceron || "", intitule };
+        items.push({ valeur_pts_odj: valeur, titreStruct });
+    });
+    if (items.length)
+        sommaire.sommaire1 = items;
+    return sommaire;
+}
+function extractMetadonnees($, filePath) {
+    let dateText = norm($("h1, h2, .page-title").first().text() || "");
+    if (!dateText)
+        dateText = norm($("p").first().text() || "");
+    const dateMatch = dateText.match(/\b(\d{1,2}\s+\w+\s+\d{4})\b/i);
+    const allText = norm($("body").text() || "");
+    const sessionMatch = allText.match(/\bsession\s+(\d{4}-\d{4})\b/i);
+    let dateSeance = dateMatch?.[1] || "";
+    if (!dateSeance) {
+        const m = filePath.match(/d(\d{4})(\d{2})(\d{2})\.xml$/i);
+        if (m)
+            dateSeance = `${m[1]}-${m[2]}-${m[3]}`;
+    }
+    dateSeance = toCRDate(dateSeance, null);
+    return {
+        dateSeance,
+        dateSeanceJour: dateSeance,
+        numSeanceJour: "",
+        numSeance: "",
+        typeAssemblee: "SN",
+        legislature: "",
+        session: sessionMatch?.[1] || "",
+        nomFichierJo: "",
+        validite: "",
+        etat: "",
+        diffusion: "",
+        version: "1.0",
+        environnement: "",
+        heureGeneration: new Date(),
+    };
+}
+function elementInAnyInterval(el, idx, intervals) {
+    const p = idx.get(el);
+    if (p == null)
+        return false;
+    for (const iv of intervals)
+        if (p >= iv.start && p < iv.end)
+            return true;
+    return false;
+}

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

@@ -0,0 +1,9 @@
+import type { CirconscriptionResult, OrganismeResult, SenateurResult } from "../rich_types/sens.js";
+export declare function findAll(): AsyncGenerator<SenateurResult, void, unknown>;
+export declare function findAllCirconscriptions(): AsyncGenerator<CirconscriptionResult, void, unknown>;
+export declare function findAllOrganismes(): AsyncGenerator<OrganismeResult, void, unknown>;
+export declare function findActif(): AsyncGenerator<{
+    senmat: string;
+    sennomuse: string | null;
+    senprenomuse: string;
+}, void, unknown>;

package/lib/src/server/sens.js

@@ -0,0 +1,353 @@
+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("sens_sen as sen")
+        .leftJoin("sens_etasen as etasen", "etasen.etasencod", "sen.etasencod")
+        .leftJoin("sens_pcs as pcs", "pcs.pcscod", "sen.pcscod")
+        .leftJoin("sens_pcs42 as pcs42", "pcs42.pcs42cod", "pcs.pcs42cod")
+        .leftJoin("sens_pcs24 as pcs24", "pcs24.pcs24cod", "pcs42.pcs24cod")
+        .leftJoin("sens_pcs8 as pcs8", "pcs8.pcs8cod", "pcs24.pcs8cod")
+        .leftJoin("sens_grppol as grppol", "grppol.grppolcod", "sen.sengrppolcodcou")
+        .leftJoin("sens_com as com", "com.orgcod", "sen.sencomcodcou")
+        .select((eb) => [
+        "sen.senmat as matricule",
+        "sen.quacod as qualite",
+        "sen.sennomuse as nom_usuel",
+        "sen.senprenomuse as prenom_usuel",
+        "sen.etasencod as etat",
+        sql `to_char(${eb.ref("sen.sendatnai")}, 'YYYY-MM-DD')`.as("date_naissance"),
+        sql `to_char(${eb.ref("sen.sendatdec")}, 'YYYY-MM-DD')`.as("date_deces"),
+        "sen.sengrppolcodcou as code_groupe_politique",
+        "sen.sengrppolliccou as groupe_politique",
+        "sen.sencomcodcou as code_commission_permanente",
+        "com.comlilmin as commission_permanente",
+        sql `${eb.ref("sen.sencirnumcou")}::text`.as("code_circonscription"),
+        "sen.sencircou as circonscription",
+        "sen.senburliccou as fonction_bureau_senat",
+        "sen.senema as courrier_electronique",
+        sql `pcs.pcslil`.as("PCS_INSEE"),
+        sql `pcs42.pcs42lib`.as("PCS_INSEE_42"),
+        sql `pcs24.pcs24lib`.as("PCS_INSEE_24"),
+        sql `pcs8.pcs8lil`.as("PCS_INSEE_8"),
+        "sen.sendespro as description_profession",
+        sql `${eb.ref("sen.sennumsie")}::text`.as("siege"),
+        "sen.sendaiurl as url_hatvp",
+        // URLs
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_senurl as senurl")
+            .select(["senurl.typurlcod as code_url", "senurl.senurlurl as url", "senurl.senurlnumtri as order_num"])
+            .whereRef("senurl.senmat", "=", "sen.senmat")
+            .orderBy("senurl.senurlnumtri", "asc")).as("urls"),
+        // Mandats sénatoriaux
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_elusen as elusen")
+            .leftJoin("sens_etadebman as etadebman", "etadebman.etadebmancod", "elusen.etadebmancod")
+            .leftJoin("sens_etafinman as etafinman", "etafinman.etafinmancod", "elusen.etafinmancod")
+            .select([
+            sql `elusen.dptnum::text`.as("code_circonscription"),
+            sql `to_char(elusen.eludatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+            sql `to_char(elusen.eludatfin, 'YYYY-MM-DD')`.as("date_fin"),
+            "elusen.temvalcod as etat",
+            "etadebman.etadebmanlib as etat_debut",
+            "etafinman.etafinman as etat_fin",
+            "elusen.eludatdeb as order_date",
+        ])
+            .whereRef("elusen.senmat", "=", "sen.senmat")
+            .orderBy("elusen.eludatdeb", (ob) => ob.desc().nullsLast())).as("mandats_senateur"),
+        // Commissions
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_memcom as memcom")
+            .leftJoin("sens_com as com2", "com2.orgcod", "memcom.orgcod")
+            .leftJoin("sens_typorg as typorg", "typorg.typorgcod", "com2.typorgcod")
+            .select((eb2) => [
+            "memcom.orgcod as code_organisme",
+            sql `to_char(memcom.memcomdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+            sql `to_char(memcom.memcomdatfin, 'YYYY-MM-DD')`.as("date_fin"),
+            "memcom.temvalcod as etat",
+            "com2.comlilmin as libelle",
+            "com2.typorgcod as type_code_organisme",
+            "typorg.typorglib as type_organisme",
+            "memcom.memcomdatdeb as order_date",
+            // Fonctions dans la commission
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("sens_fonmemcom as fonmemcom")
+                .leftJoin("sens_foncom as foncom", "foncom.foncomcod", "fonmemcom.foncomcod")
+                .select([
+                sql `to_char(fonmemcom.fonmemcomdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+                sql `to_char(fonmemcom.fonmemcomdatfin, 'YYYY-MM-DD')`.as("date_fin"),
+                sql `coalesce(
+                    nullif(foncom.foncomlib, ''),
+                    nullif(foncom.foncomlil, ''),
+                    nullif(foncom.foncomlic, ''))`.as("libelle"),
+                "fonmemcom.fonmemcomdatdeb as order_date",
+            ])
+                .whereRef("fonmemcom.memcomid", "=", "memcom.memcomid")
+                .orderBy("fonmemcom.fonmemcomdatdeb", (ob) => ob.desc().nullsLast())).as("fonctions"),
+        ])
+            .whereRef("memcom.senmat", "=", "sen.senmat")
+            .orderBy("memcom.memcomdatdeb", (ob) => ob.desc().nullsLast())).as("commissions"),
+        // Délégations
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_memdelega as memdelega")
+            .leftJoin("sens_delega as delega", "delega.orgcod", "memdelega.orgcod")
+            .leftJoin("sens_designorg as designorg", "designorg.designcod", "memdelega.designcod")
+            .leftJoin("sens_typorg as typorg2", "typorg2.typorgcod", "delega.typorgcod")
+            .select((eb2) => [
+            "memdelega.orgcod as code_organisme",
+            sql `to_char(memdelega.memdelegadatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+            sql `to_char(memdelega.memdelegadatfin, 'YYYY-MM-DD')`.as("date_fin"),
+            "memdelega.temvalcod as etat",
+            "delega.evelib as libelle",
+            "delega.typorgcod as type_code_organisme",
+            "typorg2.typorglib as type_organisme",
+            "memdelega.memdelegadatdeb as order_date",
+            // Fonctions dans la délégation
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("sens_fonmemdelega as fonmemdelega")
+                .leftJoin("sens_fondelega as fondelega", "fondelega.fondelcod", "fonmemdelega.fondelcod")
+                .select([
+                sql `to_char(fonmemdelega.fonmemdeldatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+                sql `to_char(fonmemdelega.fonmemdeldatfin, 'YYYY-MM-DD')`.as("date_fin"),
+                sql `coalesce(
+                    nullif(fondelega.fondellib, ''),
+                    nullif(fondelega.fondellil, ''),
+                    nullif(fondelega.fondellic, ''))`.as("libelle"),
+                "fonmemdelega.fonmemdeldatdeb as order_date",
+            ])
+                .whereRef("fonmemdelega.memdelegaid", "=", "memdelega.memdelegaid")
+                .orderBy("fonmemdelega.fonmemdeldatdeb", (ob) => ob.desc().nullsLast())).as("fonctions"),
+        ])
+            .whereRef("memdelega.senmat", "=", "sen.senmat")
+            .orderBy("memdelega.memdelegadatdeb", (ob) => ob.desc().nullsLast())).as("delegations"),
+        // Groupes politiques
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_memgrppol as memgrppol")
+            .leftJoin("sens_grppol as grppol2", "grppol2.grppolcod", "memgrppol.grppolcod")
+            .leftJoin("sens_typapppol as typapppol", "typapppol.typapppolcod", "memgrppol.typapppolcod")
+            .leftJoin("sens_typorg as typorg3", "typorg3.typorgcod", "grppol2.typorgcod")
+            .select((eb2) => [
+            "memgrppol.grppolcod as code_organisme",
+            sql `to_char(memgrppol.memgrppoldatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+            sql `to_char(memgrppol.memgrppoldatfin, 'YYYY-MM-DD')`.as("date_fin"),
+            "memgrppol.temvalcod as etat",
+            "grppol2.grppollibcou as libelle",
+            "grppol2.typorgcod as type_code_organisme",
+            "typorg3.typorglib as type_organisme",
+            "memgrppol.memgrppoldatdeb as order_date",
+            // Fonctions dans le groupe politique
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("sens_fonmemgrppol as fonmemgrppol")
+                .leftJoin("sens_fongrppol as fongrppol", "fongrppol.fongrppolcod", "fonmemgrppol.fongrppolcod")
+                .select([
+                sql `to_char(fonmemgrppol.fonmemgrppoldatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+                sql `to_char(fonmemgrppol.fonmemgrppoldatfin, 'YYYY-MM-DD')`.as("date_fin"),
+                sql `coalesce(
+                    nullif(fongrppol.fongrppollib, ''),
+                    nullif(fongrppol.fongrppollil, ''),
+                    nullif(fongrppol.fongrppollic, ''))`.as("libelle"),
+                "fonmemgrppol.fonmemgrppoldatdeb as order_date",
+            ])
+                .whereRef("fonmemgrppol.memgrppolid", "=", "memgrppol.memgrppolid")
+                .orderBy("fonmemgrppol.fonmemgrppoldatdeb", (ob) => ob.desc().nullsLast())).as("fonctions"),
+        ])
+            .whereRef("memgrppol.senmat", "=", "sen.senmat")
+            .orderBy("memgrppol.memgrppoldatdeb", (ob) => ob.desc().nullsLast())).as("groupes"),
+        // Fonctions au bureau du Sénat
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_senbur as senbur")
+            .leftJoin("sens_bur as bur", "bur.burcod", "senbur.burcod")
+            .select([
+            sql `to_char(senbur.senburdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
+            sql `to_char(senbur.senburdatfin, 'YYYY-MM-DD')`.as("date_fin"),
+            sql `coalesce(nullif(bur.burlib, ''), nullif(bur.burlil, ''), nullif(bur.burlic, ''))`.as("libelle"),
+            "senbur.senburdatdeb as order_date",
+        ])
+            .whereRef("senbur.senmat", "=", "sen.senmat")
+            .orderBy("senbur.senburdatdeb", (ob) => ob.desc().nullsLast())).as("fonctions_bureau"),
+        // Points de contact
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_poicon as poicon")
+            .select((eb2) => [
+            sql `poicon.poiconid::text`.as("id"),
+            "poicon.typpoiconcod as type",
+            "poicon.poiconlib as libelle",
+            "poicon.poiconnumtri as order_num",
+            // Adresses
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("sens_adresse as adresse")
+                .select([
+                "adresse.adrnumvoi as numero_voie",
+                "adresse.adrnomvoi as nom_voie",
+                "adresse.adrcmp as complement",
+                "adresse.adrcmp2 as complement2",
+                "adresse.adrcodpos as code_postal",
+                "adresse.adrcom as commune",
+                "adresse.adrcdxcod as code_cedex",
+                "adresse.adrcdxlib as libelle_cedex",
+                "adresse.adrburdis as bureau_distributeur",
+                "adresse.adrnumtri as order_num",
+            ])
+                .whereRef("adresse.poiconid", "=", "poicon.poiconid")
+                .orderBy("adresse.adrnumtri", "asc")).as("adresses"),
+            // Téléphones
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("sens_telephone as telephone")
+                .select([
+                "telephone.typtelcod as type",
+                "telephone.telnum as numero",
+                "telephone.telnumtri as order_num",
+            ])
+                .whereRef("telephone.poiconid", "=", "poicon.poiconid")
+                .orderBy("telephone.telnumtri", "asc")).as("telephones"),
+        ])
+            .whereRef("poicon.senmat", "=", "sen.senmat")
+            .orderBy("poicon.poiconnumtri", "asc")).as("points_contact"),
+    ])
+        .compile();
+    for await (const row of streamRawQuery(compiledQuery)) {
+        yield {
+            ...row,
+            commissions: row.commissions ?? [],
+            delegations: row.delegations ?? [],
+            fonctions_bureau: row.fonctions_bureau ?? [],
+            groupes: row.groupes ?? [],
+            mandats_senateur: row.mandats_senateur ?? [],
+            points_contact: row.points_contact ?? [],
+            urls: row.urls ?? [],
+        };
+    }
+}
+export async function* findAllCirconscriptions() {
+    const compiledQuery = db
+        .withSchema("senat")
+        .selectFrom("sens_dpt as dpt")
+        .leftJoin("sens_reg as reg", "reg.regcod", "dpt.regcod")
+        .select((eb) => [
+        sql `${eb.ref("dpt.dptnum")}::text`.as("identifiant"),
+        "dpt.dptcod as code",
+        "dpt.dptlib as libelle_departement",
+        "dpt.dptart as article",
+        "reg.reglib as libelle_region",
+        "dpt.temvalcod as etat",
+        sql `to_char(${eb.ref("dpt.dptdatdeb")}, 'YYYY-MM-DD')`.as("date_debut"),
+        sql `to_char(${eb.ref("dpt.dptdatfin")}, 'YYYY-MM-DD')`.as("date_fin"),
+        sql `${eb.ref("dpt.dptnbrsen")}::text`.as("nombre_senateurs"),
+        "dpt.dpturlcmp as url",
+    ])
+        .compile();
+    yield* streamRawQuery(compiledQuery);
+}
+export async function* findAllOrganismes() {
+    const compiledQuery = db
+        .withSchema("senat")
+        .selectFrom(db
+        .withSchema("senat")
+        .selectFrom("sens_com as com")
+        .select([
+        "com.orgcod",
+        "com.evelic",
+        "com.evelib",
+        "com.evelil",
+        "com.typorgcod",
+        "com.orgurlsim",
+        "com.orgdatcre",
+        "com.orgdatfin",
+        "com.temvalcod",
+    ])
+        .union(db
+        .withSchema("senat")
+        .selectFrom("sens_delega as delega")
+        .select([
+        "delega.orgcod",
+        "delega.evelic",
+        "delega.evelib",
+        "delega.evelil",
+        "delega.typorgcod",
+        "delega.orgurlsim",
+        "delega.orgdatcre",
+        "delega.orgdatfin",
+        "delega.temvalcod",
+    ]))
+        .union(db
+        .withSchema("senat")
+        .selectFrom("sens_grppol as grppol")
+        .select([
+        "grppol.grppolcod as orgcod",
+        "grppol.grppolliccou as evelic",
+        "grppol.grppollibcou as evelib",
+        "grppol.grppollilcou as evelil",
+        "grppol.typorgcod",
+        "grppol.grppolurlsim as orgurlsim",
+        "grppol.grppoldatcre as orgdatcre",
+        "grppol.grppoldatfin as orgdatfin",
+        "grppol.temvalcod",
+    ]))
+        .union(db
+        .withSchema("senat")
+        .selectFrom("sens_grpsenami as grpsenami")
+        .select([
+        "grpsenami.orgcod",
+        "grpsenami.evelic",
+        "grpsenami.evelib",
+        "grpsenami.evelil",
+        "grpsenami.typorgcod",
+        "grpsenami.orgurlsim",
+        "grpsenami.orgdatcre",
+        "grpsenami.orgdatfin",
+        "grpsenami.temvalcod",
+    ]))
+        .union(db
+        .withSchema("senat")
+        .selectFrom("sens_org as org")
+        .select([
+        "org.orgcod",
+        "org.evelic",
+        "org.evelib",
+        "org.evelil",
+        "org.typorgcod",
+        "org.orgurlsim",
+        "org.orgdatcre",
+        "org.orgdatfin",
+        "org.temvalcod",
+    ]))
+        .as("all_organismes"))
+        .leftJoin("sens_typorg as typorg", "typorg.typorgcod", "all_organismes.typorgcod")
+        .select((eb) => [
+        "all_organismes.orgcod as code",
+        "all_organismes.evelic as libelle_court",
+        "all_organismes.evelib as libelle",
+        sql `rtrim(${eb.ref("all_organismes.evelil")})`.as("libelle_long"),
+        "all_organismes.typorgcod as type_code",
+        sql `rtrim(${eb.ref("typorg.typorglib")})`.as("type_libelle"),
+        sql `'https://www.senat.fr' || ${eb.ref("all_organismes.orgurlsim")}`.as("url"),
+        sql `to_char(${eb.ref("all_organismes.orgdatcre")}, 'YYYY-MM-DD')`.as("date_debut"),
+        sql `to_char(${eb.ref("all_organismes.orgdatfin")}, 'YYYY-MM-DD')`.as("date_fin"),
+        "all_organismes.temvalcod as etat",
+    ])
+        .compile();
+    yield* streamRawQuery(compiledQuery);
+}
+export async function* findActif() {
+    const compiledQuery = db
+        .withSchema("senat")
+        .selectFrom("sens_sen as sen")
+        .select(["sen.senmat", "sen.sennomuse", "sen.senprenomuse"])
+        .where("sen.etasencod", "=", "ACTIF")
+        .compile();
+    yield* streamRawQuery(compiledQuery);
+}