@tricoteuses/senat 2.22.8 → 2.22.10

package/lib/loaders.js

@@ -0,0 +1,286 @@
+import fsex from "fs-extra";
+import fs from "fs";
+import path from "path";
+import * as git from "./git";
+import { datasets } from "./datasets";
+import { UNDEFINED_SESSION } from "./types/sessions";
+export { EnabledDatasets } from "./datasets";
+export const AGENDA_FOLDER = "agenda";
+export const COMPTES_RENDUS_FOLDER = "seances";
+export const COMMISSION_FOLDER = "commissions";
+export const DOSLEG_DOSSIERS_FOLDER = "dossiers";
+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 (err) {
+            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;
+    }
+}
+function* iterLoadSenatComptesRendusGeneric(dataDir, session, subFolder) {
+    const basePath = path.join(dataDir, subFolder, DATA_TRANSFORMED_FOLDER, String(session));
+    if (!fs.existsSync(basePath)) {
+        return;
+    }
+    const files = (fs.readdirSync(basePath) || []).filter((f) => f.endsWith(".json")).sort();
+    for (const fileName of files) {
+        const filePath = path.join(basePath, fileName);
+        try {
+            const fileContent = fs.readFileSync(filePath, "utf-8");
+            const compteRendu = JSON.parse(fileContent);
+            if (!compteRendu?.uid) {
+                console.warn(`[SN] CR without uid → ${fileName}`);
+                continue;
+            }
+            yield { compteRendu, session };
+        }
+        catch (err) {
+            console.warn(`[SN] error reading CR → ${fileName}`, err);
+        }
+    }
+}
+export function* iterLoadSenatComptesRendusSeances(dataDir, session) {
+    yield* iterLoadSenatComptesRendusGeneric(dataDir, session, COMPTES_RENDUS_FOLDER);
+}
+export function* iterLoadSenatComptesRendusCommissions(dataDir, session) {
+    yield* iterLoadSenatComptesRendusGeneric(dataDir, session, COMMISSION_FOLDER);
+}
+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* iterLoadSenatDocuments(dataDir, session, documentType, options = {}) {
+    for (const { item: dossierLegislatif } of iterLoadSenatDossiersLegislatifs(dataDir, session, options)) {
+        for (const lecture of dossierLegislatif["lectures"]) {
+            const lecturesSenat = lecture.lectures_assemblee.filter((lectureAssemblee) => lectureAssemblee.assemblee === "Sénat");
+            for (const lectureSenat of lecturesSenat) {
+                for (const document of lectureSenat[documentType]) {
+                    const enrichedDocument = {
+                        signet_dossier: dossierLegislatif["signet"],
+                        ...document,
+                    };
+                    const documentItem = {
+                        item: enrichedDocument,
+                    };
+                    if (document.url) {
+                        const documentName = path.parse(document.url).name;
+                        documentItem.filePathFromDataset = path.join(`${document.session ?? UNDEFINED_SESSION}`, documentName, `${documentName}.pdf`);
+                    }
+                    yield documentItem;
+                }
+            }
+        }
+    }
+}
+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 iterLoadSenatDocuments(dataDir, session, "textes", options)) {
+        yield iterItem;
+    }
+}
+export function loadSenatTexteContent(dataDir, textePathFromDataset) {
+    const parsedTextePath = path.parse(textePathFromDataset);
+    const jsonTexteName = `${parsedTextePath.name}.json`;
+    const fullTextePath = path.join(dataDir, TEXTE_FOLDER, DATA_TRANSFORMED_FOLDER, parsedTextePath.dir, jsonTexteName);
+    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;
+        if (!Array.isArray(gr.events))
+            gr.events = [];
+        yield { item: gr };
+    }
+}
+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/model/agenda.d.ts

@@ -0,0 +1,6 @@
+import { AgendaEvent } from "../types/agenda";
+export declare function getStartAndEndTimes(timeStr: string | null | undefined, dateISO: string): {
+    startTime: string | null;
+    endTime: string | null;
+};
+export declare function parseAgendaFromFile(htmlFilePath: string): Promise<AgendaEvent[] | null>;

package/lib/model/agenda.js

@@ -0,0 +1,148 @@
+import { JSDOM } from "jsdom";
+import { DateTime } from "luxon";
+import path from "path";
+import { ID_DATE_FORMAT, STANDARD_DATE_FORMAT } from "../scripts/datautil";
+const FR_TZ = "Europe/Paris";
+function eventIsSeance(eventElement) {
+    return eventElement.classList.contains("evt-seance");
+}
+function getEventType(eventClasses) {
+    const typeClass = [...eventClasses].find((className) => className.startsWith("evt-")) || null;
+    switch (typeClass) {
+        case "evt-seance":
+            return "Séance publique";
+        case "evt-instanz":
+            return "Commissions";
+        case "evt-cemi":
+            return "Mission de contrôle";
+        case "evt-deleg":
+            return "Offices et délégations";
+        case "evt-bureau":
+            return "Instances décisionnelles";
+    }
+    return null;
+}
+function getUrlDossierSenat(lienElements) {
+    const urlElement = [...lienElements].find((lienElement) => lienElement.textContent?.includes("dossier législatif"));
+    return urlElement ? urlElement.getAttribute("href") : null;
+}
+function getQuantieme(eventElement, seancesElements) {
+    const seanceIndex = seancesElements.indexOf(eventElement);
+    if (seancesElements.length === 1 && seanceIndex === 0) {
+        return "Unique";
+    }
+    else {
+        switch (seanceIndex) {
+            case 0:
+                return "Première";
+            case 1:
+                return "Deuxième";
+            case 2:
+                return "Troisième";
+            case 3:
+                return "Quatrième";
+            case 4:
+                return "Cinquième";
+        }
+    }
+    return "Non défini";
+}
+/**
+ * Normalize time string to become a simple start time ("H'h'mm") or a duration ("'de 'H'h'mm' à 'H'h'mm").
+ */
+function normalizeTime(timeStr) {
+    return timeStr
+        ?.replace(/^À l'issue de l'espace réservé .* et au plus tard\s/i, "") // Must be processed first
+        ?.replace(/^(?:le )?matin/i, "10h00") // We chose "matin" to mean 10h00
+        ?.replace(/^(?:l')?après-midi/i, "16h00") // We chose "après-midi" to mean 16h00
+        ?.replace(/^(?:le )?soir/i, "20h00") // We chose "soir" to mean 20h00
+        ?.replace(/^(?:la )?nuit/i, "22h00") // We chose "nuit" to mean 22h00
+        ?.replace(/^à\s/gi, "")
+        ?.replace(/heures/gi, "h00")
+        ?.replace(/\set.*/i, "")
+        ?.replace(/,.*/, "")
+        ?.replace(/\s\(hors hémicycle\)/i, "")
+        ?.replace(/\s*h\s*/gi, "h");
+}
+export function getStartAndEndTimes(timeStr, dateISO) {
+    const normalizedTime = normalizeTime(timeStr);
+    if (!normalizedTime) {
+        return { startTime: null, endTime: null };
+    }
+    const rangeMatch = normalizedTime.match(/^de (?<start>\d{1,2}h\d{2}) à (?<end>\d{1,2}h\d{2})$/i);
+    const toUtcTimeOnly = (value) => {
+        if (!value)
+            return null;
+        const time = DateTime.fromFormat(value, "H'h'mm", { zone: FR_TZ });
+        if (!time.isValid)
+            return null;
+        const local = DateTime.fromISO(dateISO, { zone: FR_TZ }).set({
+            hour: time.hour,
+            minute: time.minute,
+            second: 0,
+            millisecond: 0,
+        });
+        if (!local.isValid)
+            return null;
+        return local.toUTC().toFormat("HH:mm:ss.SSS'Z'");
+    };
+    if (rangeMatch?.groups) {
+        const { start, end } = rangeMatch.groups;
+        return {
+            startTime: toUtcTimeOnly(start),
+            endTime: toUtcTimeOnly(end),
+        };
+    }
+    return {
+        startTime: toUtcTimeOnly(normalizedTime),
+        endTime: null,
+    };
+}
+function transformAgenda(document, fileName) {
+    const agendaEvents = [];
+    const eventElements = document.querySelectorAll(".evt");
+    const seanceElements = Array.from(eventElements).filter((eventElement) => eventIsSeance(eventElement));
+    for (const eventElement of eventElements) {
+        const id = eventElement.previousElementSibling?.getAttribute("name") || null;
+        if (!id) {
+            continue;
+        }
+        const type = getEventType(eventElement.classList);
+        const date = DateTime.fromFormat(fileName, ID_DATE_FORMAT).toFormat(STANDARD_DATE_FORMAT);
+        const timeOriginal = eventElement.querySelector(".time")?.textContent || null;
+        const { startTime, endTime } = getStartAndEndTimes(timeOriginal, date);
+        const titre = eventElement.querySelector(".titre")?.textContent?.trim() || "";
+        const organe = eventElement.querySelector(".organe")?.textContent?.trim() || null;
+        const objet = eventElement.querySelector(".objet")?.textContent?.trim()?.replace(/^- /, "") || null;
+        const lieu = eventElement.querySelector(".lieu")?.textContent || null;
+        const videoElement = eventElement.querySelector(".video");
+        const urlDossierSenat = getUrlDossierSenat(eventElement.querySelectorAll(".lien a"));
+        agendaEvents.push({
+            id,
+            type,
+            date,
+            startTime,
+            endTime,
+            timeOriginal,
+            titre,
+            organe,
+            objet,
+            lieu,
+            captationVideo: videoElement !== null,
+            urlDossierSenat: urlDossierSenat,
+            quantieme: eventIsSeance(eventElement) ? getQuantieme(eventElement, seanceElements) : null,
+        });
+    }
+    return agendaEvents;
+}
+export async function parseAgendaFromFile(htmlFilePath) {
+    try {
+        const { document } = (await JSDOM.fromFile(htmlFilePath, { contentType: "text/html" })).window;
+        const fileName = path.parse(htmlFilePath).name;
+        return transformAgenda(document, fileName);
+    }
+    catch (error) {
+        console.error(`Could not parse texte with error ${error}`);
+    }
+    return null;
+}

package/lib/model/ameli.d.ts

@@ -0,0 +1,51 @@
+import { InferResult } from "kysely";
+export type AmendementResult = InferResult<typeof findAllAmendementsQuery>[0];
+declare const findAllAmendementsQuery: import("kysely").SelectQueryBuilder<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+}, "ameli.amd" | "ameli.sub" | "ameli.typsub" | "ameli.typrect" | "ameli.txt_ameli" | "ameli.etatxt" | "ameli.ses" | "ameli.typses" | "ameli.nat" | "ameli.lec_ameli" | "dosleg.texte" | "dosleg.lecass" | "ameli.mot" | "ameli.avicom" | "ameli.avigvt" | "ameli.sor" | "ameli.irr" | "ameli.grppol_ameli" | "ameli.com_ameli" | "ameli.cab", {
+    [x: string]: any;
+    nature: string;
+    date_depot: string;
+    etat: string;
+    sort: any;
+    url: string;
+    auteur_est_gouvernement: boolean;
+    scrutin_num: any;
+    auteurs: {
+        prenom: any;
+        homonyme: any;
+        nom: any;
+        qualite: any;
+        rang: any;
+        matricule: any;
+        groupe_politique_id: any;
+        group_politique_code: any;
+        groupe_politique_libelle_court: any;
+        groupe_politique_libelle: any;
+    }[];
+}>;
+export declare function findAllAmendements(fromSession?: number): AsyncIterableIterator<{
+    [x: string]: any;
+    nature: string;
+    date_depot: string;
+    etat: string;
+    sort: any;
+    url: string;
+    auteur_est_gouvernement: boolean;
+    scrutin_num: any;
+    auteurs: {
+        prenom: any;
+        homonyme: any;
+        nom: any;
+        qualite: any;
+        rang: any;
+        matricule: any;
+        groupe_politique_id: any;
+        group_politique_code: any;
+        groupe_politique_libelle_court: any;
+        groupe_politique_libelle: any;
+    }[];
+}>;
+export {};

package/lib/model/ameli.js

@@ -0,0 +1,147 @@
+import { sql } from "kysely";
+import { jsonArrayFrom } from "kysely/helpers/postgres";
+import { dbSenat } from "../databases";
+import { concat, toDateString } from "./util";
+function auteurs(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([
+        "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("ameli.amdsen.rng", "asc"));
+}
+function scrutin(amendementNum, sesann, lecassidt) {
+    return dbSenat
+        .selectFrom("dosleg.amescr")
+        .leftJoin("dosleg.scr", (join) => join
+        .onRef("dosleg.amescr.scrnum", "=", "dosleg.scr.scrnum")
+        .onRef("dosleg.amescr.sesann", "=", "dosleg.scr.sesann"))
+        .leftJoin("dosleg.date_seance", "dosleg.scr.code", "dosleg.date_seance.code")
+        .where("dosleg.amescr.amescrnum", "=", amendementNum)
+        .where("dosleg.amescr.sesann", "=", sesann)
+        .where("dosleg.date_seance.lecidt", "=", lecassidt)
+        .select(["dosleg.amescr.scrnum as scrutin_num"])
+        .limit(1)
+        .as("scrutin_num");
+}
+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("dosleg.texte", (join) => join.onRef("ameli.ses.ann", "=", "dosleg.texte.sesann").onRef("ameli.txt_ameli.numabs", "=", "dosleg.texte.texnum"))
+    .leftJoin("dosleg.lecass", "dosleg.texte.lecassidt", "dosleg.lecass.lecassidt")
+    .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")
+    .select(({ eb, ref, val }) => [
+    "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("ameli.amd.typ", "=", "A")
+        .then(val("Amendement"))
+        .when("ameli.amd.typ", "=", "M")
+        .then(val("Motion"))
+        .when("ameli.amd.typ", "=", "S")
+        .then(val("Sous-amendement"))
+        .else("")
+        .end()
+        .as("nature"),
+    "ameli.amd.id as id",
+    "ameli.amd.amdperid as parent_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",
+    "ameli.amd.txtid as texte_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.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("ameli.amd.etaid", "=", 7)
+        .then(val("Diffusé"))
+        .when("ameli.amd.etaid", "=", 8)
+        .then(val("Retiré avant réunion ou séance"))
+        .when("ameli.amd.etaid", "=", 9)
+        .then(val("Examiné en commission ou séance"))
+        .when("ameli.amd.etaid", "=", 10)
+        .then(val("Irrecevable"))
+        .when("ameli.amd.etaid", "=", 11)
+        .then(val("Irrecevable"))
+        .else("")
+        .end()
+        .as("etat"),
+    "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(eb
+        .case()
+        .when("ameli.amd.num", "like", "%COM%")
+        .then(val("https://www.senat.fr/amendements/commissions/"))
+        .else(val("https://www.senat.fr/amendements/"))
+        .end(), ref("ameli.ses.ann"), val("-"), sql `(ameli.ses.ann + 1)`, val("/"), ref("ameli.txt_ameli.numabs"), val("/Amdt_"), ref("ameli.amd.num"), 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("ameli.cab.entid", "is not", null).then(true).else(false).end().as("auteur_est_gouvernement"),
+    scrutin(ref("ameli.amd.num"), ref("ameli.ses.ann"), ref("dosleg.texte.lecassidt")),
+    auteurs(ref("ameli.amd.id")).as("auteurs"),
+]);
+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,18 @@
+import * as cheerio from "cheerio";
+import { CompteRendu } from "../types/compte_rendu";
+import { Reunion } from "../types/agenda";
+export declare function getRemainingTextAfterSpeakerHeader($: cheerio.CheerioAPI, $p: cheerio.Cheerio<any>): string;
+export type DaySection = {
+    title: string;
+    $start: cheerio.Cheerio<any>;
+    time?: string;
+};
+export declare function cleanTitle(t: string): string;
+export declare function extractDayH3Sections($: cheerio.CheerioAPI, dateISO: string): DaySection[];
+export declare function parseCommissionCRSectionFromDom($: cheerio.CheerioAPI, htmlFilePath: string, opts: {
+    dateISO: string;
+    hourShort: string | null;
+    organe?: string | null;
+    section: DaySection;
+    matched?: Reunion;
+}): CompteRendu | null;