@tricoteuses/senat 3.0.1 → 3.1.0

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

@@ -0,0 +1,32 @@
+import { Kysely, sql as kyselySql, type CompiledQuery } from "kysely";
+import type AmeliDatabase from "../kysely_types/ameli/Database.js";
+import type DebatsDatabase from "../kysely_types/debats/Database.js";
+import type DoslegDatabase from "../kysely_types/dosleg/Database.js";
+import type QuestionsDatabase from "../kysely_types/questions/Database.js";
+import type SensDatabase from "../kysely_types/sens/Database.js";
+/** Merged Kysely database type covering all senat sub-schemas. */
+export type SenatDatabase = AmeliDatabase & DebatsDatabase & DoslegDatabase & QuestionsDatabase & SensDatabase;
+/**
+ * Fully-typed Kysely database connection.
+ * Tables must be referenced through the "senat" schema, e.g. in raw sql:
+ *   `sql\`select * from senat.sens_sen\``
+ * or using the query builder:
+ *   `db.withSchema("senat").selectFrom("sens_sen")`
+ */
+export declare const db: Kysely<SenatDatabase>;
+/**
+ * Streams the result of a raw Kysely compiled query, yielding one row at a time.
+ *
+ * @example
+ * ```ts
+ * import { db, streamRawQuery } from "./databases_postgres.js"
+ * import { sql } from "kysely"
+ *
+ * const query = sql<{ senmat: string }>`select senmat from senat.sens_sen`
+ * for await (const row of streamRawQuery<{ senmat: string }>(query.compile(db))) {
+ *   console.log(row.senmat)
+ * }
+ * ```
+ */
+export declare function streamRawQuery<T>(compiledQuery: CompiledQuery, batchSize?: number): AsyncGenerator<T, void, unknown>;
+export { kyselySql as sql };

package/lib/src/server/databases_postgres.js

@@ -0,0 +1,50 @@
+import { Pool } from "pg";
+import { Kysely, PostgresDialect, sql as kyselySql } from "kysely";
+import config from "./config.js";
+// ---------------------------------------------------------------------------
+// Kysely instance (uses pg driver so .stream() is available)
+// ---------------------------------------------------------------------------
+const pool = new Pool({
+    database: config.db.name,
+    host: config.db.host,
+    password: config.db.password,
+    port: config.db.port,
+    user: config.db.user,
+});
+/**
+ * Fully-typed Kysely database connection.
+ * Tables must be referenced through the "senat" schema, e.g. in raw sql:
+ *   `sql\`select * from senat.sens_sen\``
+ * or using the query builder:
+ *   `db.withSchema("senat").selectFrom("sens_sen")`
+ */
+export const db = new Kysely({
+    dialect: new PostgresDialect({ pool }),
+});
+// ---------------------------------------------------------------------------
+// Streaming helper
+// ---------------------------------------------------------------------------
+/**
+ * Streams the result of a raw Kysely compiled query, yielding one row at a time.
+ *
+ * @example
+ * ```ts
+ * import { db, streamRawQuery } from "./databases_postgres.js"
+ * import { sql } from "kysely"
+ *
+ * const query = sql<{ senmat: string }>`select senmat from senat.sens_sen`
+ * for await (const row of streamRawQuery<{ senmat: string }>(query.compile(db))) {
+ *   console.log(row.senmat)
+ * }
+ * ```
+ */
+export async function* streamRawQuery(compiledQuery, batchSize = 100) {
+    const stream = db.getExecutor().stream(compiledQuery, batchSize);
+    for await (const chunk of stream) {
+        for (const row of chunk.rows) {
+            yield row;
+        }
+    }
+}
+// Re-export Kysely's sql tag for convenience.
+export { kyselySql as sql };

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

@@ -0,0 +1,38 @@
+export interface Dataset {
+    database: string;
+    repairEncoding: boolean;
+    repairZip?: (dataset: Dataset, dataDir: string) => void;
+    title: string;
+    url: string;
+    indexes?: {
+        [table: string]: Array<{
+            name: string;
+            columns: string[];
+        }>;
+    };
+    mergeKeys?: {
+        [table: string]: string[];
+    };
+    rowMultisetMergeTables?: string[];
+}
+export interface Datasets {
+    ameli: Dataset;
+    debats: Dataset;
+    dosleg: Dataset;
+    questions: Dataset;
+    sens: Dataset;
+}
+export declare enum EnabledDatasets {
+    None = 0,
+    Ameli = 1,
+    Debats = 2,
+    DosLeg = 4,
+    Questions = 8,
+    Sens = 16,
+    PhotosSenateurs = 32,
+    Agenda = 64,
+    All = 127
+}
+export declare const datasets: Datasets;
+export declare function getEnabledDatasets(categories: string[]): EnabledDatasets;
+export declare function getChosenDatasets(enabledDatasets: EnabledDatasets): Dataset[];

package/lib/src/server/datasets.js

@@ -0,0 +1,247 @@
+import fs from "fs-extra";
+import path from "path";
+import assert from "assert";
+export var EnabledDatasets;
+(function (EnabledDatasets) {
+    EnabledDatasets[EnabledDatasets["None"] = 0] = "None";
+    EnabledDatasets[EnabledDatasets["Ameli"] = 1] = "Ameli";
+    EnabledDatasets[EnabledDatasets["Debats"] = 2] = "Debats";
+    EnabledDatasets[EnabledDatasets["DosLeg"] = 4] = "DosLeg";
+    EnabledDatasets[EnabledDatasets["Questions"] = 8] = "Questions";
+    EnabledDatasets[EnabledDatasets["Sens"] = 16] = "Sens";
+    EnabledDatasets[EnabledDatasets["PhotosSenateurs"] = 32] = "PhotosSenateurs";
+    EnabledDatasets[EnabledDatasets["Agenda"] = 64] = "Agenda";
+    EnabledDatasets[EnabledDatasets["All"] = 127] = "All";
+})(EnabledDatasets || (EnabledDatasets = {}));
+export const datasets = {
+    ameli: {
+        database: "ameli",
+        repairEncoding: true,
+        repairZip: (dataset, dataDir) => {
+            const sqlFilename = `${dataset.database}.sql`;
+            const sqlFilePath = path.join(dataDir, sqlFilename);
+            fs.removeSync(sqlFilePath);
+            fs.moveSync(path.join(dataDir, "var", "opt", "opendata", sqlFilename), sqlFilePath);
+        },
+        title: "Amendements",
+        url: "https://data.senat.fr/data/ameli/ameli.zip",
+        indexes: {
+            amdsen: [
+                { name: "idx_amdid", columns: ["amdid"] },
+                { name: "idx_senid", columns: ["senid"] },
+                { name: "idx_grpid", columns: ["grpid"] },
+            ],
+            sen_ameli: [{ name: "idx_entid", columns: ["entid"] }],
+            grppol_ameli: [{ name: "idx_entid", columns: ["entid"] }],
+            sub: [
+                { name: "idx_id", columns: ["id"] },
+                { name: "idx_typid", columns: ["typid"] },
+                { name: "idx_merid", columns: ["merid"] },
+                { name: "idx_comdelid", columns: ["comdelid"] },
+            ],
+            typsub: [{ name: "idx_id", columns: ["id"] }],
+            typrect: [{ name: "idx_id", columns: ["id"] }],
+            txt_ameli: [
+                { name: "idx_id", columns: ["id"] },
+                { name: "idx_txtetaid", columns: ["txtetaid"] },
+                { name: "idx_sesdepid", columns: ["sesdepid"] },
+                { name: "idx_natid", columns: ["natid"] },
+                { name: "idx_lecid", columns: ["lecid"] },
+            ],
+            etatxt: [{ name: "idx_id", columns: ["id"] }],
+            ses: [
+                { name: "idx_id", columns: ["id"] },
+                { name: "idx_typid", columns: ["typid"] },
+                { name: "idx_ann", columns: ["ann"] },
+            ],
+            typses: [{ name: "idx_id", columns: ["id"] }],
+            nat: [{ name: "idx_id", columns: ["id"] }],
+            lec_ameli: [{ name: "idx_id", columns: ["id"] }],
+            mot: [{ name: "idx_id", columns: ["id"] }],
+            avicom: [{ name: "idx_id", columns: ["id"] }],
+            avigvt: [{ name: "idx_id", columns: ["id"] }],
+            sor: [{ name: "idx_id", columns: ["id"] }],
+            irr: [{ name: "idx_id", columns: ["id"] }],
+            com_ameli: [{ name: "idx_entid", columns: ["entid"] }],
+            cab: [{ name: "idx_entid", columns: ["entid"] }],
+            amd: [
+                { name: "idx_subid", columns: ["subid"] },
+                { name: "idx_typrectid", columns: ["typrectid"] },
+                { name: "idx_txtid", columns: ["txtid"] },
+                { name: "idx_motid", columns: ["motid"] },
+                { name: "idx_avcid", columns: ["avcid"] },
+                { name: "idx_avgid", columns: ["avgid"] },
+                { name: "idx_sorid", columns: ["sorid"] },
+                { name: "idx_irrid", columns: ["irrid"] },
+                { name: "idx_nomentid", columns: ["nomentid"] },
+            ],
+        },
+    },
+    debats: {
+        database: "debats",
+        repairEncoding: false,
+        title: "Informations relatives aux comptes rendus intégraux de la séance publique",
+        url: "https://data.senat.fr/data/debats/debats.zip",
+        indexes: {
+            secdis: [
+                { name: "idx_datsea", columns: ["datsea"] },
+                { name: "idx_typseccod", columns: ["typseccod"] },
+            ],
+            intpjl: [{ name: "idx_secdiscle", columns: ["secdiscle"] }],
+            secdivers: [
+                { name: "idx_datsea", columns: ["datsea"] },
+                { name: "idx_typseccod", columns: ["typseccod"] },
+            ],
+            intdivers: [{ name: "idx_intdiverscle", columns: ["intdiverscle"] }],
+            lecassdeb: [{ name: "idx_datsea", columns: ["datsea"] }],
+        },
+    },
+    dosleg: {
+        database: "dosleg",
+        repairEncoding: false,
+        title: "Dossiers législatifs",
+        url: "https://data.senat.fr/data/dosleg/dosleg.zip",
+        indexes: {
+            amescr: [{ name: "idx_scrnum", columns: ["scrnum"] }],
+            auteur: [{ name: "idx_autcod", columns: ["autcod"] }],
+            corscr: [{ name: "idx_scrnum", columns: ["scrnum"] }],
+            date_seance: [
+                { name: "idx_code", columns: ["code"] },
+                { name: "idx_lecidt", columns: ["lecidt"] },
+            ],
+            deccoc: [{ name: "idx_deccoccod", columns: ["deccoccod"] }],
+            etaloi: [{ name: "idx_etaloicod", columns: ["etaloicod"] }],
+            lecass: [
+                { name: "idx_lecidt", columns: ["lecidt"] },
+                { name: "idx_codass", columns: ["codass"] },
+                { name: "idx_orgcod", columns: ["orgcod"] },
+                { name: "idx_orippr", columns: ["orippr"] },
+            ],
+            lecassrap: [
+                { name: "idx_rapcod", columns: ["rapcod"] },
+                { name: "idx_lecassidt", columns: ["lecassidt"] },
+            ],
+            lecture: [
+                { name: "idx_loicod", columns: ["loicod"] },
+                { name: "idx_typleccod", columns: ["typleccod"] },
+                { name: "idx_lecidt", columns: ["lecidt"] },
+            ],
+            loi: [
+                { name: "idx_typloicod", columns: ["typloicod"] },
+                { name: "idx_etaloicod", columns: ["etaloicod"] },
+                { name: "idx_deccoccod", columns: ["deccoccod"] },
+                { name: "idx_loicod", columns: ["loicod"] },
+            ],
+            loithe: [
+                { name: "idx_thecle", columns: ["thecle"] },
+                { name: "idx_loicod", columns: ["loicod"] },
+            ],
+            posvot: [{ name: "idx_posvotcod", columns: ["posvotcod"] }],
+            rap: [
+                { name: "idx_rapcod", columns: ["rapcod"] },
+                { name: "idx_coddenrap", columns: ["coddenrap"] },
+            ],
+            rolsig: [{ name: "idx_signataire", columns: ["signataire"] }],
+            scr: [
+                { name: "idx_code", columns: ["code"] },
+                { name: "idx_scrnum", columns: ["scrnum"] },
+                { name: "idx_sesann", columns: ["sesann"] },
+            ],
+            stavot: [{ name: "idx_stavotidt", columns: ["stavotidt"] }],
+            texte: [
+                { name: "idx_lecassidt", columns: ["lecassidt"] },
+                { name: "idx_oritxtcod", columns: ["oritxtcod"] },
+                { name: "idx_typtxtcod", columns: ["typtxtcod"] },
+                { name: "idx_texcod", columns: ["texcod"] },
+            ],
+            the: [{ name: "idx_thecle", columns: ["thecle"] }],
+            titsen: [{ name: "idx_titsencod", columns: ["titsencod"] }],
+            typloi: [{ name: "idx_typloicod", columns: ["typloicod"] }],
+            typtxt: [{ name: "idx_typtxtcod", columns: ["typtxtcod"] }],
+            votsen: [
+                { name: "idx_scrnum", columns: ["scrnum"] },
+                { name: "idx_sesann", columns: ["sesann"] },
+                { name: "idx_titsencod", columns: ["titsencod"] },
+                { name: "idx_stavotidt", columns: ["stavotidt"] },
+                { name: "idx_posvotcod", columns: ["posvotcod"] },
+                { name: "idx_senmat", columns: ["senmat"] },
+            ],
+        },
+        mergeKeys: {
+            corscr: ["sesann", "scrnum", "corscrord"],
+            docsea: ["evtseacle", "docseaord"],
+            gen: ["gencod"],
+        },
+        rowMultisetMergeTables: ["amescr"],
+    },
+    questions: {
+        database: "questions",
+        repairEncoding: false,
+        title: "Questions écrites et orales posées par les sénateurs au Gouvernement",
+        url: "https://data.senat.fr/data/questions/questions.zip",
+        indexes: {
+            tam_reponses: [{ name: "idx_idque", columns: ["idque"] }],
+            tam_questions: [
+                { name: "idx_sorquecod", columns: ["sorquecod"] },
+                { name: "idx_etaquecod", columns: ["etaquecod"] },
+            ],
+            the: [{ name: "idx_thenouidt", columns: ["thenouidt"] }],
+            sortquestion: [{ name: "idx_sorquecod", columns: ["sorquecod"] }],
+            etatquestion: [{ name: "idx_etaquecod", columns: ["etaquecod"] }],
+        },
+        rowMultisetMergeTables: ["tam_reponses"],
+    },
+    sens: {
+        database: "sens",
+        repairEncoding: false,
+        repairZip: (dataset, dataDir) => {
+            const sqlFilename = `${dataset.database}.sql`;
+            const sqlFilePath = path.join(dataDir, sqlFilename);
+            fs.removeSync(sqlFilePath);
+            fs.moveSync(path.join(dataDir, "export_sens.sql"), sqlFilePath);
+        },
+        title: "Sénateurs (y compris organes et présence)",
+        url: "https://data.senat.fr/data/senateurs/export_sens.zip",
+        indexes: {
+            dpt: [
+                { name: "idx_dptnum", columns: ["dptnum"] },
+                { name: "idx_regcod", columns: ["regcod"] },
+            ],
+            activite_loi: [{ name: "idx_actid", columns: ["actid"] }],
+            activite_delegation: [{ name: "idx_actid", columns: ["actid"] }],
+            activite_participant: [{ name: "idx_senmat", columns: ["senmat"] }],
+            activite_senateur: [{ name: "idx_senmat", columns: ["senmat"] }],
+            senbur: [
+                { name: "idx_senmat", columns: ["senmat"] },
+                { name: "idx_burcod", columns: ["burcod"] },
+            ],
+            elucan: [
+                { name: "idx_senmat", columns: ["senmat"] },
+                { name: "idx_typmancod", columns: ["typmancod"] },
+            ],
+        },
+        mergeKeys: {
+            activite: ["actid"],
+        },
+    },
+};
+function getEnabledDatasetByName(datasetName) {
+    const enabledDataset = EnabledDatasets[datasetName];
+    return typeof enabledDataset === "number" ? enabledDataset : undefined;
+}
+export function getEnabledDatasets(categories) {
+    categories.map((datasetName) => assert.notStrictEqual(getEnabledDatasetByName(datasetName), undefined, `Unknown name of dataset: ${datasetName}`));
+    return categories.reduce((enabledDatasets, datasetName) => {
+        const enabledDataset = getEnabledDatasetByName(datasetName);
+        return enabledDatasets | (enabledDataset || EnabledDatasets.None);
+    }, EnabledDatasets.None);
+}
+export function getChosenDatasets(enabledDatasets) {
+    return [
+        enabledDatasets & EnabledDatasets.Ameli ? datasets.ameli : null,
+        enabledDatasets & EnabledDatasets.Debats ? datasets.debats : null,
+        enabledDatasets & EnabledDatasets.DosLeg ? datasets.dosleg : null,
+        enabledDatasets & EnabledDatasets.Questions ? datasets.questions : null,
+        enabledDatasets & EnabledDatasets.Sens ? datasets.sens : null,
+    ].filter((dataset) => dataset !== null);
+}

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

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

package/lib/src/server/debats.js

@@ -0,0 +1,98 @@
+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("debats_debats as debats")
+        .select((eb) => [
+        sql `to_char(${eb.ref("debats.datsea")}, 'YYYYMMDD')`.as("id"),
+        sql `to_char(${eb.ref("debats.datsea")}, 'YYYY-MM-DD')`.as("date_seance"),
+        sql `${eb.ref("debats.numero")}::text`.as("numero"),
+        "debats.deburl as url",
+        "debats.debsyn as etat_synchronisation",
+        // Sections principales (PJL)
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("debats_secdis as secdis")
+            .leftJoin("debats_typsec as typsec", "typsec.typseccod", "secdis.typseccod")
+            .select((eb2) => [
+            sql `secdis.secdisordid::text`.as("id"),
+            "secdis.secdisnum as numero",
+            "secdis.secdisobj as objet",
+            "secdis.secdisurl as url",
+            "typsec.typseclib as type",
+            "typsec.typseccat as categorie",
+            "secdis.lecassidt as lecture_id",
+            // Interventions de la section
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("debats_intpjl as intpjl")
+                .leftJoin("dosleg_auteur as auteur", "auteur.autcod", "intpjl.autcod")
+                .select([
+                sql `intpjl.intordid::text`.as("id"),
+                "intpjl.autcod as auteur_code",
+                "intpjl.intfon as fonction_intervenant",
+                "intpjl.inturl as url",
+                "intpjl.intana as analyse",
+                sql `json_build_object(
+                    'code', auteur.autcod,
+                    'nom', auteur.nomuse,
+                    'prenom', auteur.prenom,
+                    'matricule', auteur.autmat
+                  )`.as("auteur"),
+            ])
+                .whereRef("intpjl.secdiscle", "=", "secdis.secdiscle")
+                .orderBy("intpjl.intordid", "asc")).as("interventions"),
+        ])
+            .whereRef("secdis.datsea", "=", "debats.datsea")
+            .orderBy("secdis.secdisordid", "asc")).as("sections"),
+        // Sections diverses
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("debats_secdivers as secdivers")
+            .leftJoin("debats_typsec as typsec", "typsec.typseccod", "secdivers.typseccod")
+            .select((eb2) => [
+            "secdivers.secdiverslibelle as libelle",
+            "secdivers.secdiversobj as objet",
+            "typsec.typseclib as type",
+            "typsec.typseccat as categorie",
+            // Interventions diverses
+            jsonArrayFrom(eb2
+                .withSchema("senat")
+                .selectFrom("debats_intdivers as intdivers")
+                .leftJoin("dosleg_auteur as auteur", "auteur.autcod", "intdivers.autcod")
+                .select([
+                sql `intdivers.intdiversordid::text`.as("id"),
+                "intdivers.autcod as auteur_code",
+                "intdivers.intfon as fonction_intervenant",
+                "intdivers.inturl as url",
+                "intdivers.intana as analyse",
+                sql `json_build_object(
+                    'code', auteur.autcod,
+                    'nom', auteur.nomuse,
+                    'prenom', auteur.prenom,
+                    'matricule', auteur.autmat
+                  )`.as("auteur"),
+            ])
+                .whereRef("intdivers.secdiverscle", "=", "secdivers.secdiverscle")
+                .orderBy("intdivers.intdiversordid", "asc")).as("interventions"),
+        ])
+            .whereRef("secdivers.datsea", "=", "debats.datsea")).as("sections_divers"),
+        // Lectures
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("debats_lecassdeb as lecassdeb")
+            .select(["lecassdeb.lecassidt as id"])
+            .whereRef("lecassdeb.datsea", "=", "debats.datsea")).as("lectures"),
+    ])
+        .compile();
+    for await (const row of streamRawQuery(compiledQuery)) {
+        yield {
+            ...row,
+            lectures: row.lectures ?? [],
+            sections: row.sections ?? [],
+            sections_divers: row.sections_divers ?? [],
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { DocumentResult } from "../documents.js";
+export declare function findAllTextes(): AsyncGenerator<DocumentResult, void, unknown>;
+export declare function findAllRapports(): AsyncGenerator<DocumentResult, void, unknown>;

package/lib/src/server/documents.js

@@ -0,0 +1,132 @@
+import { sql } from "kysely";
+import { jsonArrayFrom } from "kysely/helpers/postgres";
+import { db, streamRawQuery } from "./databases_postgres.js";
+export async function* findAllTextes() {
+    const compiledQuery = db
+        .withSchema("senat")
+        .selectFrom("dosleg_texte as texte")
+        .leftJoin("dosleg_oritxt as oritxt", "oritxt.oritxtcod", "texte.oritxtcod")
+        .leftJoin("dosleg_typtxt as typtxt", "typtxt.typtxtcod", "texte.typtxtcod")
+        .leftJoin("dosleg_lecass as lecass", "lecass.lecassidt", "texte.lecassidt")
+        .leftJoin("dosleg_lecture as lecture", "lecture.lecidt", "lecass.lecidt")
+        .leftJoin("dosleg_loi as loi", "loi.loicod", "lecture.loicod")
+        .select((eb) => [
+        "loi.signet as signet_dossier",
+        "texte.texnum as numero",
+        "texte.orgcod as code_organisme",
+        sql `
+        case
+          when ${eb.ref("texte.texurl")} is not null then
+            regexp_replace(regexp_replace(trim(${eb.ref("texte.texurl")}), '#+$', ''), '^(.*/)?(.*?)(\.html)?$', '\2')
+          else null
+        end
+      `.as("id"),
+        sql `
+        case
+          when ${eb.ref("texte.typurl")} = 'I' then regexp_replace('https://www.senat.fr/leg/' || rtrim(${eb.ref("texte.texurl")}), '#+$', '')
+          else regexp_replace(rtrim(${eb.ref("texte.texurl")}), '#+$', '')
+        end
+      `.as("url"),
+        sql `rtrim(${eb.ref("oritxt.oritxtlib")})`.as("origine"),
+        "oritxt.oriordre as ordre_origine",
+        "oritxt.oritxtado as code_adoption",
+        "oritxt.oritxtmod as modification",
+        sql `rtrim(${eb.ref("typtxt.typtxtlib")})`.as("type"),
+        sql `to_char(${eb.ref("texte.txtoritxtdat")}, 'YYYY-MM-DD')`.as("date"),
+        sql `${eb.ref("texte.sesann")}::int`.as("session"),
+        // Auteurs
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("dosleg_auteur as auteur")
+            .leftJoin("dosleg_ecr as ecr", "ecr.autcod", "auteur.autcod")
+            .leftJoin("dosleg_rolsig as rolsig", "rolsig.signataire", "ecr.signataire")
+            .select([
+            "auteur.prenom as prenom",
+            "auteur.nomuse as nom_usuel",
+            "auteur.autmat as matricule",
+            sql `ecr.ecrnumtri::text`.as("ordre"),
+            "ecr.ecrnumtri as ordre_num",
+            "rolsig.rolsiglib as role",
+            "ecr.ecrqua as qualite",
+        ])
+            .whereRef("ecr.texcod", "=", "texte.texcod")).as("auteurs"),
+        sql `null::text`.as("titre"),
+    ])
+        .orderBy(sql `array_position(array['0','2','1'], oritxt.oriordre)`)
+        .compile();
+    for await (const row of streamRawQuery(compiledQuery)) {
+        yield {
+            ...row,
+            auteurs: row.auteurs ?? [],
+        };
+    }
+}
+export async function* findAllRapports() {
+    const compiledQuery = db
+        .withSchema("senat")
+        .selectFrom("dosleg_rap as rap")
+        .leftJoin("dosleg_raporg as raporg", "raporg.rapcod", "rap.rapcod")
+        .leftJoin("dosleg_denrap as denrap", "denrap.coddenrap", "rap.coddenrap")
+        .leftJoin("dosleg_lecassrap as lecassrap", "lecassrap.rapcod", "rap.rapcod")
+        .leftJoin("dosleg_lecass as lecass", "lecass.lecassidt", "lecassrap.lecassidt")
+        .leftJoin("dosleg_lecture as lecture", "lecture.lecidt", "lecass.lecidt")
+        .leftJoin("dosleg_loi as loi", "loi.loicod", "lecture.loicod")
+        .select((eb) => [
+        "loi.signet as signet_dossier",
+        "rap.rapnum as numero",
+        "raporg.orgcod as code_organisme",
+        sql `
+        case
+          when ${eb.ref("rap.rapurl")} is not null then
+            regexp_replace(regexp_replace(trim(${eb.ref("rap.rapurl")}), '#+$', ''), '^(.*/)?(.*?)(\.html)?$', '\2')
+          else null
+        end
+      `.as("id"),
+        sql `
+        case
+          when ${eb.ref("rap.typurl")} = 'I' then regexp_replace('https://www.senat.fr/rap/' || rtrim(${eb.ref("rap.rapurl")}), '#+$', '')
+          else regexp_replace(rtrim(${eb.ref("rap.rapurl")}), '#+$', '')
+        end
+      `.as("url"),
+        sql `rtrim(${eb.ref("denrap.libdenrap")})`.as("type"),
+        sql `rtrim(rtrim(${eb.ref("rap.raptil")}))`.as("titre"),
+        sql `rtrim(rtrim(${eb.ref("rap.rapsoustit")}))`.as("sous_titre"),
+        sql `to_char(${eb.ref("rap.date_depot")}, 'YYYY-MM-DD')`.as("date"),
+        sql `${eb.ref("rap.sesann")}::int`.as("session"),
+        // Auteurs
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("dosleg_auteur as auteur")
+            .leftJoin("dosleg_ecr as ecr", "ecr.autcod", "auteur.autcod")
+            .leftJoin("dosleg_rolsig as rolsig", "rolsig.signataire", "ecr.signataire")
+            .select([
+            "auteur.prenom as prenom",
+            "auteur.nomuse as nom_usuel",
+            "auteur.autmat as matricule",
+            sql `ecr.ecrnumtri::text`.as("ordre"),
+            "ecr.ecrnumtri as ordre_num",
+            "rolsig.rolsiglib as role",
+            "ecr.ecrqua as qualite",
+        ])
+            .whereRef("ecr.rapcod", "=", "rap.rapcod")).as("auteurs"),
+        // Documents annexes
+        jsonArrayFrom(eb
+            .withSchema("senat")
+            .selectFrom("dosleg_docatt as docatt")
+            .leftJoin("dosleg_typatt as typatt", "typatt.typattcod", "docatt.typattcod")
+            .select(["docatt.docatturl as url", "typatt.typattlib as type_document"])
+            .whereRef("docatt.rapcod", "=", "rap.rapcod")).as("documents_annexes"),
+        sql `null::text`.as("origine"),
+        sql `null::text`.as("ordre_origine"),
+        sql `null::text`.as("code_adoption"),
+        sql `null::text`.as("modification"),
+    ])
+        .compile();
+    for await (const row of streamRawQuery(compiledQuery)) {
+        yield {
+            ...row,
+            auteurs: row.auteurs ?? [],
+            documents_annexes: row.documents_annexes ?? [],
+        };
+    }
+}

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

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