@tricoteuses/senat 2.10.5 → 2.11.1

package/lib/model/ameli.js

@@ -1,128 +1,135 @@
 import { jsonArrayFrom } from "kysely/helpers/postgres";
-import { dbAmeli } from "../databases";
+import { dbSenat } from "../databases";
 import { concat, toDateString } from "./util";
 function auteurs(amendementId) {
-    return jsonArrayFrom(dbAmeli
-        .selectFrom("amdsen")
-        .leftJoin("sen_ameli", "amdsen.senid", "sen_ameli.entid")
-        .leftJoin("grppol_ameli", "amdsen.grpid", "grppol_ameli.entid")
-        .where("amdsen.amdid", "=", amendementId)
+    return jsonArrayFrom(dbSenat
+        .selectFrom("ameli.amdsen")
+        .leftJoin("ameli.sen_ameli", "ameli.amdsen.senid", "ameli.sen_ameli.entid")
+        .leftJoin("ameli.grppol_ameli", "ameli.amdsen.grpid", "ameli.grppol_ameli.entid")
+        .where("ameli.amdsen.amdid", "=", amendementId)
         .select([
-        "amdsen.prenomuse as prenom",
-        "amdsen.hom as homonyme",
-        "amdsen.nomuse as nom",
-        "amdsen.qua as qualite",
-        "amdsen.rng as rang",
-        "sen_ameli.mat as matricule",
-        "amdsen.grpid as groupe_politique_id",
-        "grppol_ameli.cod as group_politique_code",
-        "grppol_ameli.libcou as groupe_politique_libelle_court",
-        "grppol_ameli.lilcou as groupe_politique_libelle",
+        "ameli.amdsen.prenomuse as prenom",
+        "ameli.amdsen.hom as homonyme",
+        "ameli.amdsen.nomuse as nom",
+        "ameli.amdsen.qua as qualite",
+        "ameli.amdsen.rng as rang",
+        "ameli.sen_ameli.mat as matricule",
+        "ameli.amdsen.grpid as groupe_politique_id",
+        "ameli.grppol_ameli.cod as group_politique_code",
+        "ameli.grppol_ameli.libcou as groupe_politique_libelle_court",
+        "ameli.grppol_ameli.lilcou as groupe_politique_libelle",
     ])
-        .orderBy("amdsen.rng asc"));
+        .orderBy("ameli.amdsen.rng asc"));
 }
-const findAllQuery = dbAmeli
-    .selectFrom("amd")
-    .leftJoin("sub", "amd.subid", "sub.id")
-    .leftJoin("typsub", "sub.typid", "typsub.id")
-    .leftJoin("typrect", "amd.typrectid", "typrect.id")
-    .leftJoin("txt_ameli", "amd.txtid", "txt_ameli.id")
-    .leftJoin("etatxt", "txt_ameli.txtetaid", "etatxt.id")
-    .leftJoin("ses", "txt_ameli.sesdepid", "ses.id")
-    .leftJoin("typses", "typses.id", "ses.typid")
-    .leftJoin("nat", "txt_ameli.natid", "nat.id")
-    .leftJoin("lec_ameli", "txt_ameli.lecid", "lec_ameli.id")
-    .leftJoin("mot", "amd.motid", "mot.id")
-    .leftJoin("avicom", "amd.avcid", "avicom.id")
-    .leftJoin("avigvt", "amd.avgid", "avigvt.id")
-    .leftJoin("sor", "amd.sorid", "sor.id")
-    .leftJoin("irr", "amd.irrid", "irr.id")
-    .leftJoin("grppol_ameli", "amd.nomentid", "grppol_ameli.entid")
-    .leftJoin("com_ameli", "amd.nomentid", "com_ameli.entid")
-    .leftJoin("cab", "amd.nomentid", "cab.entid")
+const findAllAmendementsQuery = dbSenat
+    .selectFrom("ameli.amd")
+    .leftJoin("ameli.sub", "ameli.amd.subid", "ameli.sub.id")
+    .leftJoin("ameli.typsub", "ameli.sub.typid", "ameli.typsub.id")
+    .leftJoin("ameli.typrect", "ameli.amd.typrectid", "ameli.typrect.id")
+    .leftJoin("ameli.txt_ameli", "ameli.amd.txtid", "ameli.txt_ameli.id")
+    .leftJoin("ameli.etatxt", "ameli.txt_ameli.txtetaid", "ameli.etatxt.id")
+    .leftJoin("ameli.ses", "ameli.txt_ameli.sesdepid", "ameli.ses.id")
+    .leftJoin("ameli.typses", "ameli.typses.id", "ameli.ses.typid")
+    .leftJoin("ameli.nat", "ameli.txt_ameli.natid", "ameli.nat.id")
+    .leftJoin("ameli.lec_ameli", "ameli.txt_ameli.lecid", "ameli.lec_ameli.id")
+    .leftJoin("ameli.mot", "ameli.amd.motid", "ameli.mot.id")
+    .leftJoin("ameli.avicom", "ameli.amd.avcid", "ameli.avicom.id")
+    .leftJoin("ameli.avigvt", "ameli.amd.avgid", "ameli.avigvt.id")
+    .leftJoin("ameli.sor", "ameli.amd.sorid", "ameli.sor.id")
+    .leftJoin("ameli.irr", "ameli.amd.irrid", "ameli.irr.id")
+    .leftJoin("ameli.grppol_ameli", "ameli.amd.nomentid", "ameli.grppol_ameli.entid")
+    .leftJoin("ameli.com_ameli", "ameli.amd.nomentid", "ameli.com_ameli.entid")
+    .leftJoin("ameli.cab", "ameli.amd.nomentid", "ameli.cab.entid")
+    .leftJoin("dosleg.amescr", "ameli.amd.num", "dosleg.amescr.amescrnum")
     .select(({ eb, ref, val }) => [
-    "ses.ann as session",
-    "ses.lil as session_libelle",
-    "typses.lib as type_session",
-    "txt_ameli.doslegsignet as signet_dossier_legislatif",
-    "nat.libcourt as nature_texte",
-    "nat.lib as nature_texte_libelle",
-    "txt_ameli.numabs as numero_texte",
-    "txt_ameli.numado as numero_adoption_texte",
-    "txt_ameli.int as intitule_texte",
-    "etatxt.lic as etat_texte",
-    "etatxt.lib as etat_texte_libelle",
-    "etatxt.txttyp as type_texte",
-    "lec_ameli.lib as lecture",
+    "ameli.ses.ann as session",
+    "ameli.ses.lil as session_libelle",
+    "ameli.typses.lib as type_session",
+    "ameli.txt_ameli.doslegsignet as signet_dossier_legislatif",
+    "ameli.nat.libcourt as nature_texte",
+    "ameli.nat.lib as nature_texte_libelle",
+    "ameli.txt_ameli.numabs as numero_texte",
+    "ameli.txt_ameli.numado as numero_adoption_texte",
+    "ameli.txt_ameli.int as intitule_texte",
+    "ameli.etatxt.lic as etat_texte",
+    "ameli.etatxt.lib as etat_texte_libelle",
+    "ameli.etatxt.txttyp as type_texte",
+    "ameli.lec_ameli.lib as lecture",
     eb
         .case()
-        .when("amd.typ", "=", "A")
+        .when("ameli.amd.typ", "=", "A")
         .then(val("Amendement"))
-        .when("amd.typ", "=", "M")
+        .when("ameli.amd.typ", "=", "M")
         .then(val("Motion"))
-        .when("amd.typ", "=", "S")
+        .when("ameli.amd.typ", "=", "S")
         .then(val("Sous-amendement"))
         .else("")
         .end()
         .as("nature"),
-    "amd.id as id",
-    "amd.amdperid as parent_id",
-    "amd.amdrendusim as rendu_similaire_id",
-    "amd.ideid as identique_id",
-    "amd.discomid as discussion_commune_id",
-    "amd.num as numero",
-    "amd.numabs as numero_absolu",
-    "amd.ord as ordre",
-    "amd.accgou as accepte_gouvernement",
-    "sub.lib as subdivision_libelle",
-    "sub.lic as subdivision_libelle_court",
-    "sub.pos as subdivision_position_texte",
-    "sub.posder as subdivision_position_discussion",
-    "sub.merid as subdivision_mere_id",
-    "sub.sig as subdivision_signet",
-    "sub.comdelid as subdivision_commission_id",
-    "sub.dupl as subdivision_dupliquee",
-    "typsub.lib as subdivision_type",
-    "amd.alinea as alinea",
-    "amd.commentprobleme as commentaire_probleme",
-    "amd.obs as observations",
-    "amd.mot as observations_additionnelles",
-    toDateString(ref("amd.datdep")).as("date_depot"),
-    "amd.dis as dispositif",
-    "amd.obj as objet",
-    "typrect.lib as type_rectification",
-    "mot.lib as motion_libelle",
+    "ameli.amd.id as id",
+    "ameli.amd.amdperid as parent_id",
+    "ameli.amd.amdrendusim as rendu_similaire_id",
+    "ameli.amd.ideid as identique_id",
+    "ameli.amd.discomid as discussion_commune_id",
+    "ameli.amd.num as numero",
+    "ameli.amd.numabs as numero_absolu",
+    "ameli.amd.ord as ordre",
+    "ameli.amd.accgou as accepte_gouvernement",
+    "dosleg.amescr.scrnum as scrutin_id",
+    "ameli.sub.lib as subdivision_libelle",
+    "ameli.sub.lic as subdivision_libelle_court",
+    "ameli.sub.pos as subdivision_position_texte",
+    "ameli.sub.posder as subdivision_position_discussion",
+    "ameli.sub.merid as subdivision_mere_id",
+    "ameli.sub.sig as subdivision_signet",
+    "ameli.sub.comdelid as subdivision_commission_id",
+    "ameli.sub.dupl as subdivision_dupliquee",
+    "ameli.typsub.lib as subdivision_type",
+    "ameli.amd.alinea as alinea",
+    "ameli.amd.commentprobleme as commentaire_probleme",
+    "ameli.amd.obs as observations",
+    "ameli.amd.mot as observations_additionnelles",
+    toDateString(ref("ameli.amd.datdep")).as("date_depot"),
+    "ameli.amd.dis as dispositif",
+    "ameli.amd.obj as objet",
+    "ameli.typrect.lib as type_rectification",
+    "ameli.mot.lib as motion_libelle",
     eb
         .case()
-        .when("amd.etaid", "=", 7)
+        .when("ameli.amd.etaid", "=", 7)
         .then(val("Diffusé"))
-        .when("amd.etaid", "=", 8)
+        .when("ameli.amd.etaid", "=", 8)
         .then(val("Retiré avant réunion ou séance"))
-        .when("amd.etaid", "=", 9)
+        .when("ameli.amd.etaid", "=", 9)
         .then(val("Examiné en commission ou séance"))
-        .when("amd.etaid", "=", 10)
+        .when("ameli.amd.etaid", "=", 10)
         .then(val("Irrecevable"))
-        .when("amd.etaid", "=", 11)
+        .when("ameli.amd.etaid", "=", 11)
         .then(val("Irrecevable"))
         .else("")
         .end()
         .as("etat"),
-    "avicom.lib as avis_commission",
-    "avigvt.lib as avis_gouvernement",
-    eb.fn.coalesce("sor.lib", "irr.libirr").as("sort"),
-    "amd.rev as revision",
-    concat(val("https://www.senat.fr/amendements/"), ref("ses.lil"), val("/"), ref("txt_ameli.numabs"), val("/Amdt_"), ref("amd.numabs"), val(".html")).as("url"),
-    "grppol_ameli.lilcou as au_nom_de_groupe_politique",
-    "com_ameli.lil as au_nom_de_commission",
+    "ameli.avicom.lib as avis_commission",
+    "ameli.avigvt.lib as avis_gouvernement",
+    eb.fn.coalesce("ameli.sor.lib", "ameli.irr.libirr").as("sort"),
+    "ameli.amd.rev as revision",
+    concat(val("https://www.senat.fr/amendements/"), ref("ameli.ses.lil"), val("/"), ref("ameli.txt_ameli.numabs"), val("/Amdt_"), ref("ameli.amd.numabs"), val(".html")).as("url"),
+    "ameli.grppol_ameli.lilcou as au_nom_de_groupe_politique",
+    "ameli.com_ameli.lil as au_nom_de_commission",
     eb
         .case()
-        .when("cab.entid", "is not", null)
+        .when("ameli.cab.entid", "is not", null)
         .then(true)
         .else(false)
         .end()
         .as("auteur_est_gouvernement"),
-    auteurs(ref("amd.id")).as("auteurs"),
+    auteurs(ref("ameli.amd.id")).as("auteurs")
 ]);
-export function findAll() {
-    return findAllQuery.stream();
+export function findAllAmendements(fromSession) {
+    if (fromSession !== undefined) {
+        return findAllAmendementsQuery
+            .where("ameli.ses.ann", ">=", fromSession)
+            .stream();
+    }
+    return findAllAmendementsQuery.stream();
 }

package/lib/model/commission.d.ts

@@ -0,0 +1,5 @@
+import * as cheerio from "cheerio";
+import { CompteRendu } from "../types/compte_rendu";
+import { GroupedReunion } from "../types/agenda";
+export declare function getRemainingTextAfterSpeakerHeader($: cheerio.CheerioAPI, $p: cheerio.Cheerio<any>): string;
+export declare function parseCommissionCRFromFile(htmlFilePath: string, best: GroupedReunion): CompteRendu | null;

package/lib/model/commission.js

@@ -0,0 +1,263 @@
+import * as cheerio from "cheerio";
+import path from "path";
+import fs from "fs";
+import { norm, toCRDate } from "./util";
+const PARA_h3_SEL = "p.sh_justify, p.sh_center, p.sh_marge, p[align], li, h3";
+function findDayRoot($, targetISO) {
+    let $root = $();
+    $("h2").each((_, el) => {
+        const txt = norm($(el).text());
+        const m = txt.match(/(?:Lundi|Mardi|Mercredi|Jeudi|Vendredi|Samedi|Dimanche)\s+(.+)$/i);
+        const iso = m ? frDateToISO(m[1]) : undefined;
+        if (iso === targetISO && $root.length === 0)
+            $root = $(el);
+    });
+    return $root;
+}
+function normalizeSpaces(s) {
+    return s.replace(/[\u00A0\u202F\u2009]/g, " ");
+}
+function stripIntroPunct(s) {
+    return s.replace(/^[\s]*[.:;]?\s*(?:[–—-]\s*)+/u, "");
+}
+function collectLeadingHeaderStrongEls($, $clone) {
+    const els = [];
+    const nodes = $clone.contents().toArray();
+    for (const node of nodes) {
+        if (node.type === "text") {
+            if (norm(node.data || ""))
+                break;
+            continue;
+        }
+        if (node.type === "tag") {
+            const $n = $(node);
+            if ($n.is("strong, b")) {
+                els.push(node);
+                continue;
+            }
+            if ($n.is("a") && $n.children("strong, b").length) {
+                $n.children("strong, b").each((_, el) => {
+                    els.push($(el));
+                });
+                continue;
+            }
+            break;
+        }
+    }
+    return els;
+}
+// Remove orateur's name from text and clean intro punct
+export function getRemainingTextAfterSpeakerHeader($, $p) {
+    const $clone = $p.clone();
+    // 1) Remove <strong> at start
+    const headerStrongEls = collectLeadingHeaderStrongEls($, $clone);
+    for (const el of headerStrongEls)
+        $(el).remove();
+    // 2) normalize + clean intro punct
+    let remainingHtml = $clone.html() || "";
+    remainingHtml = normalizeSpaces(cheerio.load(remainingHtml).text());
+    remainingHtml = stripIntroPunct(remainingHtml);
+    const remainingText = norm(remainingHtml || "");
+    return remainingText;
+}
+function buildPointsFromParagraphs($, paras) {
+    const points = [];
+    let ordreAbsoluSeance = 0;
+    const normSpeaker = (s) => s
+        .normalize("NFKC")
+        .replace(/\s+/g, " ")
+        .replace(/[:\.]\s*$/, "")
+        .trim();
+    const normQual = (s) => s
+        .normalize("NFKC")
+        .replace(/\s+/g, " ")
+        .replace(/^\s*,\s*|\s+$/g, "")
+        .replace(/[\s\u00A0]*[.,;:–—-]+$/u, "")
+        .trim();
+    let currentOrateur = null;
+    let currentQualite = "";
+    let currentTexte = "";
+    function isPresidentQual(qual) {
+        return /\bprésident(e)?\b/i.test(qual);
+    }
+    // Flush the buffered speaker’s text into points[] if any.
+    function flush() {
+        if (!currentOrateur || !currentTexte.trim())
+            return;
+        ordreAbsoluSeance++;
+        points.push({
+            code_grammaire: "PAROLE_GENERIQUE",
+            roledebat: isPresidentQual(currentQualite) ? "président" : "",
+            ordre_absolu_seance: String(ordreAbsoluSeance),
+            orateurs: { orateur: { nom: currentOrateur, id: "", qualite: currentQualite || "" } },
+            texte: { _: currentTexte.trim() },
+        });
+        currentOrateur = null;
+        currentQualite = "";
+        currentTexte = "";
+    }
+    function addPoint(payload) {
+        ordreAbsoluSeance++;
+        points.push({ ...payload, ordre_absolu_seance: String(ordreAbsoluSeance) });
+    }
+    for (const $p of paras) {
+        if ($p.closest("table").length)
+            continue;
+        const tagName = ($p.prop("tagName") || "").toString().toLowerCase();
+        const rawText = ($p.text() || "").replace(/\u00a0/g, " ").trim();
+        const text = norm(rawText);
+        if (!text || text.length <= 3)
+            continue;
+        const html = ($p.html() || "").trim();
+        const italicSpans = $p.find("i, em, span[style*='italic']");
+        const firstItalicOuter = italicSpans.length ? $(italicSpans[0]).prop("outerHTML") || "" : "";
+        const htmlBeforeFirstItalic = firstItalicOuter ? html.split(firstItalicOuter)[0].trim() : "";
+        const isPureItalic = italicSpans.length > 0 && italicSpans.length === $p.find("span,i,em").length && htmlBeforeFirstItalic === "";
+        if (tagName === "h3") {
+            flush();
+            addPoint({
+                code_style: "Titre",
+                code_grammaire: "TITRE_TEXTE_DISCUSSION",
+                texte: { _: text },
+            });
+            continue;
+        }
+        const boldSpans = $p.find("strong, b");
+        const joinedBold = norm(boldSpans
+            .map((_, el) => $(el).text() || "")
+            .get()
+            .join(""));
+        const [namePartRaw, qualPartRaw] = joinedBold.split(/\s*,\s+/, 2);
+        const namePart = namePartRaw ? normSpeaker(namePartRaw) : "";
+        const qualPart = qualPartRaw ? normQual(qualPartRaw) : "";
+        const looksLikeName = namePart.length > 3 && /^(M\.|Mme)[\s\u00A0\u202F]+/i.test(namePart);
+        const startsWithName = namePart && text.startsWith(namePart);
+        const isNewSpeaker = looksLikeName && startsWithName && namePart !== currentOrateur;
+        if (isNewSpeaker) {
+            flush();
+            currentOrateur = namePart;
+            currentQualite = qualPart;
+            const remainingText = getRemainingTextAfterSpeakerHeader($, $p);
+            currentTexte = remainingText;
+            continue;
+        }
+        if (isPureItalic || (!joinedBold && !currentOrateur && text)) {
+            flush();
+            addPoint({
+                code_style: "Info Italiques",
+                code_grammaire: "PAROLE_GENERIQUE",
+                texte: { _: "<i>" + text + "</i>" },
+            });
+            continue;
+        }
+        // concat text because same orateur
+        if (currentOrateur) {
+            const removeOrateurFromText = getRemainingTextAfterSpeakerHeader($, $p);
+            currentTexte += (currentTexte ? "<br/><br/>" : "") + removeOrateurFromText;
+            continue;
+        }
+    }
+    flush();
+    return points;
+}
+function frDateToISO(s) {
+    if (!s)
+        return;
+    const months = {
+        janvier: 1,
+        fevrier: 2,
+        février: 2,
+        mars: 3,
+        avril: 4,
+        mai: 5,
+        juin: 6,
+        juillet: 7,
+        aout: 8,
+        août: 8,
+        septembre: 9,
+        octobre: 10,
+        novembre: 11,
+        decembre: 12,
+        décembre: 12,
+    };
+    const m = norm(s).match(/^(\d{1,2})\s+([A-Za-zéûôîà]+)\s+(\d{4})$/i);
+    if (!m)
+        return;
+    const d = Number(m[1]);
+    const mon = months[m[2].toLowerCase()];
+    const y = Number(m[3]);
+    if (!mon)
+        return;
+    return `${y}-${String(mon).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+export function parseCommissionCRFromFile(htmlFilePath, best) {
+    try {
+        const raw = fs.readFileSync(htmlFilePath, "utf8");
+        const $ = cheerio.load(raw, { xmlMode: false });
+        const dateISO = best.date;
+        const dateSeance = toCRDate(dateISO, best.startTime);
+        const $dayRoot = findDayRoot($, dateISO);
+        if ($dayRoot.length === 0) {
+            console.warn(`[COM-CR][parse] day root not found for ${dateISO} in ${path.basename(htmlFilePath)}`);
+            return null;
+        }
+        let points = [];
+        // Take all paragraphs/h3 until next h2
+        const dayParas = [];
+        let $cursor = $dayRoot.next();
+        while ($cursor.length && !$cursor.is("h2")) {
+            if ($cursor.is("h3")) {
+                dayParas.push($cursor);
+            }
+            if ($cursor.is(PARA_h3_SEL)) {
+                dayParas.push($cursor);
+            }
+            else {
+                const $ps = $cursor.find(PARA_h3_SEL);
+                if ($ps.length) {
+                    $ps.each((_, p) => {
+                        dayParas.push($(p));
+                    });
+                }
+            }
+            $cursor = $cursor.next();
+        }
+        const allDayPoints = buildPointsFromParagraphs($, dayParas);
+        if (allDayPoints.length > 0)
+            points = allDayPoints;
+        const session = dateISO.slice(5, 7) >= "10"
+            ? `${dateISO.slice(0, 4)}-${Number(dateISO.slice(0, 4)) + 1}`
+            : `${Number(dateISO.slice(0, 4)) - 1}-${dateISO.slice(0, 4)}`;
+        const contenu = {
+            quantiemes: { journee: dateISO, session },
+            point: points,
+        };
+        const metadonnees = {
+            dateSeance: dateSeance,
+            dateSeanceJour: dateISO,
+            numSeanceJour: "",
+            numSeance: "",
+            typeAssemblee: "SN",
+            legislature: "",
+            session,
+            nomFichierJo: path.basename(htmlFilePath),
+            validite: "non-certifie",
+            etat: "definitif",
+            diffusion: "publique",
+            version: "1",
+            environnement: "prod",
+            heureGeneration: new Date(),
+        };
+        return {
+            uid: best.uid.replace(/^RUSN/, "CRC"),
+            seanceRef: best.uid,
+            sessionRef: session,
+            metadonnees,
+            contenu,
+        };
+    }
+    catch (e) {
+        console.error(`[COM-CR][parse] error file=${path.basename(htmlFilePath)}:`, e);
+        return null;
+    }
+}

package/lib/model/debats.d.ts

@@ -1,81 +1,43 @@
 import { InferResult } from "kysely";
 export type DebatResult = InferResult<typeof findAllQuery>[0];
-declare const findAllQuery: import("kysely").SelectQueryBuilder<import("../databases").SenatDb, "debats", {
+declare const findAllQuery: import("kysely").SelectQueryBuilder<any, "debats", {
+    [x: string]: any;
     id: string;
     date_seance: string;
-    numero: number | null;
-    url: string | null;
-    etat_synchronisation: string | null;
     sections: {
-        id: number | null;
-        numero: string | null;
-        objet: string | null;
-        url: string | null;
-        type: string | null;
-        categorie: string | null;
+        [x: string]: any;
         interventions: {
-            id: number | null;
-            auteur_code: string;
-            fonction_intervenant: string | null;
-            url: string | null;
-            analyse: string | null;
+            [x: string]: any;
         }[];
-        lecture_id: string;
     }[];
     sections_divers: {
-        type: string | null;
-        categorie: string | null;
-        libelle: string | null;
-        objet: string | null;
+        [x: string]: any;
         interventions: {
-            id: number | null;
-            auteur_code: string;
-            fonction_intervenant: string | null;
-            url: string | null;
-            analyse: string | null;
+            [x: string]: any;
         }[];
     }[];
     lectures: {
-        id: string;
+        id: any;
     }[];
 }>;
 export declare function findAll(): AsyncIterableIterator<{
+    [x: string]: any;
     id: string;
     date_seance: string;
-    numero: number | null;
-    url: string | null;
-    etat_synchronisation: string | null;
     sections: {
-        id: number | null;
-        numero: string | null;
-        objet: string | null;
-        url: string | null;
-        type: string | null;
-        categorie: string | null;
+        [x: string]: any;
         interventions: {
-            id: number | null;
-            auteur_code: string;
-            fonction_intervenant: string | null;
-            url: string | null;
-            analyse: string | null;
+            [x: string]: any;
         }[];
-        lecture_id: string;
     }[];
     sections_divers: {
-        type: string | null;
-        categorie: string | null;
-        libelle: string | null;
-        objet: string | null;
+        [x: string]: any;
         interventions: {
-            id: number | null;
-            auteur_code: string;
-            fonction_intervenant: string | null;
-            url: string | null;
-            analyse: string | null;
+            [x: string]: any;
         }[];
     }[];
     lectures: {
-        id: string;
+        id: any;
     }[];
 }>;
 export {};

package/lib/model/documents.d.ts

@@ -0,0 +1,2 @@
+export declare function findSenatTexteUrls(sessions?: number[]): any;
+export declare function findSenatRapportUrls(sessions?: number[]): any;

package/lib/model/documents.js

@@ -0,0 +1,37 @@
+import { dbSenat } from "../databases";
+import { rtrim } from "./util";
+export function findSenatTexteUrls(sessions = []) {
+    return dbSenat
+        .withSchema("dosleg")
+        .selectFrom("texte")
+        .where("texurl", "is not", null)
+        .where("typurl", "=", "I")
+        .$if(sessions.length > 0, (qb) => qb.where("sesann", "in", sessions))
+        .select(({ eb, ref }) => [
+        "sesann as session",
+        rtrim(ref("texurl")).as("url"),
+        eb
+            .case()
+            .when("oritxtcod", "=", "1")
+            .then(true)
+            .else(false)
+            .end()
+            .as("hasExposeDesMotifs"),
+    ])
+        .$narrowType()
+        .stream();
+}
+export function findSenatRapportUrls(sessions = []) {
+    return dbSenat
+        .withSchema("dosleg")
+        .selectFrom("rap")
+        .where("rapurl", "is not", null)
+        .where("typurl", "=", "I")
+        .$if(sessions.length > 0, (qb) => qb.where("sesann", "in", sessions))
+        .select(({ ref }) => [
+        "sesann as session",
+        rtrim(ref("rapurl")).as("url"),
+    ])
+        .$narrowType()
+        .stream();
+}