@tricoteuses/senat 3.0.2 → 3.1.1

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

@@ -0,0 +1,43 @@
+import "dotenv/config";
+import { z } from "zod";
+export declare const dbSchema: z.ZodObject<{
+    host: z.ZodString;
+    name: z.ZodString;
+    password: z.ZodString;
+    port: z.ZodCoercedNumber<unknown>;
+    user: z.ZodString;
+}, z.core.$strip>;
+export type DbConfig = z.infer<typeof dbSchema>;
+export declare const configSchema: z.ZodObject<{
+    db: z.ZodObject<{
+        host: z.ZodString;
+        name: z.ZodString;
+        password: z.ZodString;
+        port: z.ZodCoercedNumber<unknown>;
+        user: z.ZodString;
+    }, z.core.$strip>;
+    stagingDb: z.ZodObject<{
+        host: z.ZodString;
+        name: z.ZodString;
+        password: z.ZodString;
+        port: z.ZodCoercedNumber<unknown>;
+        user: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const _default: {
+    db: {
+        host: string;
+        name: string;
+        password: string;
+        port: number;
+        user: string;
+    };
+    stagingDb: {
+        host: string;
+        name: string;
+        password: string;
+        port: number;
+        user: string;
+    };
+};
+export default _default;

package/lib/src/server/config.js

@@ -0,0 +1,37 @@
+import "dotenv/config";
+import { z } from "zod";
+export const dbSchema = z.object({
+    host: z.string().trim().min(1, "Must not be empty"),
+    name: z.string().trim().min(1, "Must not be empty"),
+    password: z.string().trim().min(1, "Must not be empty"),
+    port: z.coerce.number().int().min(0).max(65535),
+    user: z.string().trim().min(1, "Must not be empty"),
+});
+export const configSchema = z.object({
+    db: dbSchema,
+    stagingDb: dbSchema,
+});
+const config = {
+    db: {
+        host: process.env["DB_HOST"] || "localhost",
+        name: process.env["DB_NAME"] || "senat",
+        password: process.env["DB_PASSWORD"] || "opendata",
+        port: process.env["DB_PORT"] || 5432,
+        user: process.env["DB_USER"] || "opendata",
+    },
+    stagingDb: {
+        host: process.env["STAGING_DB_HOST"] || process.env["DB_HOST"] || "localhost",
+        name: process.env["STAGING_DB_NAME"] || "senat_staging",
+        password: process.env["STAGING_DB_PASSWORD"] || process.env["DB_PASSWORD"] || "opendata",
+        port: process.env["STAGING_DB_PORT"] || process.env["DB_PORT"] || 5432,
+        user: process.env["STAGING_DB_USER"] || process.env["DB_USER"] || "opendata",
+    },
+};
+const result = configSchema.safeParse(config);
+if (!result.success) {
+    const issues = JSON.stringify(result.error.issues, null, 2);
+    const serializedConfig = JSON.stringify(config, null, 2);
+    console.error(`Error in configuration:\n${serializedConfig}\nError:\n${issues}`);
+    process.exit(-1);
+}
+export default result.data;

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

@@ -0,0 +1,11 @@
+export interface SenatMetadata {
+    number: string | null;
+    session: string | null;
+    date: string | null;
+    type: string | null;
+    authors: string | null;
+    title: string | null;
+    commission: string | null;
+}
+export declare function extractMetadata(xmlDoc: Document): SenatMetadata;
+export declare function convertSenatXmlToHtml(texteXml: string, outputFilePath: string): Promise<void>;

package/lib/src/server/conversion_textes.js

@@ -0,0 +1,320 @@
+import { JSDOM } from "jsdom";
+import fs from "fs-extra";
+import path from "path";
+import { DateTime } from "luxon";
+export function extractMetadata(xmlDoc) {
+    const metadata = {
+        number: null,
+        session: null,
+        date: null,
+        type: null,
+        authors: null,
+        title: xmlDoc.querySelector("docTitle")?.textContent?.trim() || null,
+        commission: null,
+    };
+    // Extract Number
+    const docIdAlias = xmlDoc.querySelector('FRBRalias[name="signet-dossier-legislatif-senat"]');
+    if (docIdAlias) {
+        const value = docIdAlias.getAttribute("value");
+        if (value) {
+            const match = value.match(/\d+$/);
+            if (match)
+                metadata.number = match[0];
+        }
+    }
+    // Extract Session
+    const sessionUri = xmlDoc.querySelector("FRBRExpression > FRBRuri")?.getAttribute("value");
+    if (sessionUri) {
+        const match = sessionUri.match(/\d{4}-\d{4}/);
+        if (match)
+            metadata.session = match[0];
+    }
+    // Extract Date
+    const depotDate = xmlDoc.querySelector('FRBRdate[name="#depot"]')?.getAttribute("date");
+    if (depotDate) {
+        metadata.date = DateTime.fromISO(depotDate).setLocale("fr").toFormat("d MMMM yyyy");
+    }
+    else {
+        const presentationDate = xmlDoc.querySelector('FRBRdate[name="#presentation"]')?.getAttribute("date");
+        if (presentationDate) {
+            metadata.date = DateTime.fromISO(presentationDate).setLocale("fr").toFormat("d MMMM yyyy");
+        }
+    }
+    // Extract Type
+    const bill = xmlDoc.querySelector("bill");
+    const typeCode = bill?.getAttribute("name");
+    if (typeCode === "ppl") {
+        metadata.type = "PROPOSITION DE LOI";
+    }
+    else if (typeCode === "pjl") {
+        metadata.type = "PROJET DE LOI";
+    }
+    // Extract Authors
+    const authorRef = xmlDoc.querySelector('FRBRWork > FRBRauthor[as="#auteur"]')?.getAttribute("href");
+    if (authorRef) {
+        const authorId = authorRef.replace(/^#/, "");
+        const authorPerson = xmlDoc.querySelector(`TLCPerson[eId="${authorId}"]`);
+        if (authorPerson) {
+            const showAs = authorPerson.getAttribute("showAs");
+            if (showAs) {
+                metadata.authors = showAs.replace(/, Sénateurs$/, ", Sénateurs et Sénatrices");
+            }
+        }
+    }
+    // Extract Commission
+    const commissionNode = xmlDoc.querySelector('TLCOrganization[eId="commission-senat"]') ||
+        xmlDoc.querySelector('TLCOrganization[eId^="commission-"]:not([eId*="assemblee"])');
+    if (commissionNode) {
+        metadata.commission = commissionNode.getAttribute("showAs");
+    }
+    return metadata;
+}
+export async function convertSenatXmlToHtml(texteXml, outputFilePath) {
+    let xmlDoc;
+    try {
+        xmlDoc = new JSDOM(texteXml, { contentType: "text/xml" }).window.document;
+    }
+    catch (err) {
+        if (await fs.pathExists(outputFilePath)) {
+            await fs.remove(outputFilePath);
+        }
+        throw err;
+    }
+    const metadata = extractMetadata(xmlDoc);
+    const xmlBody = xmlDoc.querySelector("body");
+    const style = `
+body {
+  font-family: "URW Bookman", "Bookman Old Style", serif;
+  max-width: 800px;
+  margin: 40px auto;
+  line-height: 1.5;
+  color: #333;
+}
+.header {
+  text-align: center;
+  margin-bottom: 40px;
+  border-bottom: 2px solid #333;
+  padding-bottom: 20px;
+}
+.header-top {
+  font-weight: bold;
+  font-size: 1.2em;
+  margin-bottom: 10px;
+}
+.header-session {
+  text-transform: uppercase;
+  font-size: 0.9em;
+  margin-bottom: 5px;
+}
+.header-date {
+  font-size: 0.9em;
+  margin-bottom: 5px;
+}
+.header-number {
+  font-weight: bold;
+  font-size: 1.1em;
+  margin-bottom: 20px;
+}
+.header-type {
+  font-weight: bold;
+  font-size: 1.5em;
+  margin-top: 20px;
+}
+.header-authors {
+  margin-top: 20px;
+  font-style: italic;
+}
+.header-commission {
+  margin-top: 15px;
+  font-size: 0.9em;
+}
+h1 {
+  text-align: center;
+  font-size: 1.8em;
+  margin-top: 10px;
+}
+p {
+  margin: 0.6em 0;
+}
+p.has-alinea {
+  position: relative;
+  padding-left: 2.5em;
+}
+.alinea {
+  position: absolute;
+  left: 0;
+  top: 0.15em;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 1.5em;
+  height: 1.5em;
+  padding: 0 0.3em;
+  margin-right: 0.3em;
+  font-size: 0.75em;
+  font-weight: bold;
+  color: #555;
+  background-color: #f0f0f0;
+  border: 1px solid #ccc;
+  border-radius: 1em;
+}
+.num {
+  font-weight: bold;
+  margin-right: 0.2em;
+}
+.article {
+  margin-top: 2em;
+}
+.article h3 {
+  border-bottom: 1px solid #eee;
+  padding-bottom: 5px;
+}
+`;
+    const htmlDocTemplate = `<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="utf-8">
+  <title>${metadata.title || "Document Sénat"}</title>
+  <style>${style}</style>
+</head>
+<body>
+  <div class="header">
+    <div class="header-top">SÉNAT</div>
+    <div class="header-session">SESSION ORDINAIRE DE ${metadata.session || "...."}</div>
+    ${metadata.date ? `<div class="header-date">Enregistré à la Présidence du Sénat le ${metadata.date}</div>` : ""}
+    <div class="header-number">N° ${metadata.number || "...."}</div>
+    <div class="header-type">${metadata.type || ""}</div>
+    <div class="header-authors">${metadata.authors || ""}</div>
+    ${metadata.commission
+        ? [
+            `<div class="header-commission">Envoyée à la ${metadata.commission.toLowerCase()},`,
+            "sous réserve de la constitution éventuelle d'une commission spéciale dans les conditions prévues",
+            "par le Règlement.</div>",
+        ].join(" ")
+        : ""}
+  </div>
+  <h1>${metadata.title || ""}</h1>
+</body>
+</html>`;
+    const { document: htmlDoc } = new JSDOM(htmlDocTemplate).window;
+    const body = htmlDoc.body;
+    if (xmlBody) {
+        const processNode = (xmlNode, htmlParent, alineaData = null) => {
+            const children = Array.from(xmlNode.childNodes);
+            const alineaChildren = [];
+            const otherChildren = [];
+            for (const child of children) {
+                if (child.nodeType === 1 && child.tagName.toLowerCase() === "alinea") {
+                    alineaChildren.push(child);
+                }
+                else {
+                    otherChildren.push(child);
+                }
+            }
+            for (const child of otherChildren) {
+                if (child.nodeType === 3) {
+                    htmlParent.appendChild(htmlDoc.createTextNode(child.textContent || ""));
+                }
+                else if (child.nodeType === 1) {
+                    const element = child;
+                    const tagName = element.tagName.toLowerCase();
+                    let htmlElement = null;
+                    switch (tagName) {
+                        case "article": {
+                            htmlElement = htmlDoc.createElement("div");
+                            htmlElement.className = "article";
+                            const artId = element.getAttribute("eId");
+                            if (artId)
+                                htmlElement.id = artId;
+                            const artGuid = element.getAttribute("GUID");
+                            if (artGuid)
+                                htmlElement.setAttribute("data-guid", artGuid);
+                            break;
+                        }
+                        case "num": {
+                            const parentTagName = element.parentElement?.tagName.toLowerCase();
+                            if (parentTagName === "alinea" && alineaData) {
+                                alineaData.numText = element.textContent?.trim();
+                                continue;
+                            }
+                            htmlElement = htmlDoc.createElement("span");
+                            htmlElement.className = "num";
+                            break;
+                        }
+                        case "heading":
+                            htmlElement = htmlDoc.createElement("h4");
+                            break;
+                        case "p":
+                            htmlElement = htmlDoc.createElement("p");
+                            if (alineaData) {
+                                htmlElement.classList.add("has-alinea");
+                                if (alineaData.id)
+                                    htmlElement.id = alineaData.id;
+                                if (alineaData.guid)
+                                    htmlElement.setAttribute("data-guid", alineaData.guid);
+                                const pastille = alineaData.pastille;
+                                if (pastille) {
+                                    htmlElement.setAttribute("data-pastille", pastille);
+                                    if (!alineaData.pastilleApplied) {
+                                        const span = htmlDoc.createElement("span");
+                                        span.className = "alinea";
+                                        span.setAttribute("data-alinea", pastille);
+                                        span.textContent = pastille;
+                                        htmlElement.appendChild(span);
+                                        alineaData.pastilleApplied = true;
+                                    }
+                                }
+                                if (alineaData.numText) {
+                                    const xmlPText = element.textContent || "";
+                                    const normalize = (s) => s.replace(/[\\s\\u00A0]+/g, " ").trim();
+                                    const normalizedNum = normalize(alineaData.numText);
+                                    const normalizedP = normalize(xmlPText);
+                                    if (normalizedNum && !normalizedP.startsWith(normalizedNum)) {
+                                        const numSpan = htmlDoc.createElement("span");
+                                        numSpan.className = "num";
+                                        numSpan.textContent = alineaData.numText + " ";
+                                        htmlElement.appendChild(numSpan);
+                                    }
+                                    alineaData.numText = null;
+                                }
+                            }
+                            break;
+                        case "content":
+                            processNode(element, htmlParent, alineaData);
+                            continue;
+                        case "doctitle":
+                            continue;
+                        case "i":
+                        case "b":
+                        case "u":
+                        case "sup":
+                        case "sub":
+                            htmlElement = htmlDoc.createElement(tagName);
+                            break;
+                        default:
+                            htmlElement = htmlDoc.createElement("span");
+                            htmlElement.setAttribute("data-xml-tag", tagName);
+                            break;
+                    }
+                    if (htmlElement) {
+                        htmlParent.appendChild(htmlElement);
+                        processNode(element, htmlElement, alineaData);
+                    }
+                }
+            }
+            for (const element of alineaChildren) {
+                const nextAlineaData = {
+                    id: element.getAttribute("eId"),
+                    guid: element.getAttribute("GUID"),
+                    pastille: element.getAttribute("data:pastille"),
+                    pastilleApplied: false,
+                };
+                processNode(element, htmlParent, nextAlineaData);
+            }
+        };
+        processNode(xmlBody, body);
+    }
+    const htmlContent = "<!DOCTYPE html>\n" + htmlDoc.documentElement.outerHTML;
+    await fs.ensureDir(path.dirname(outputFilePath));
+    await fs.outputFile(outputFilePath, htmlContent);
+}

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/{datasets.d.ts → src/server/datasets.d.ts}

@@ -10,6 +10,10 @@ export interface Dataset {
             columns: string[];
         }>;
     };
+    mergeKeys?: {
+        [table: string]: string[];
+    };
+    rowMultisetMergeTables?: string[];
 }
 export interface Datasets {
     ameli: Dataset;

package/lib/{datasets.js → src/server/datasets.js}

@@ -167,6 +167,12 @@ export const datasets = {
                 { name: "idx_senmat", columns: ["senmat"] },
             ],
         },
+        mergeKeys: {
+            corscr: ["sesann", "scrnum", "corscrord"],
+            docsea: ["evtseacle", "docseaord"],
+            gen: ["gencod"],
+        },
+        rowMultisetMergeTables: ["amescr"],
     },
     questions: {
         database: "questions",
@@ -183,6 +189,7 @@ export const datasets = {
             sortquestion: [{ name: "idx_sorquecod", columns: ["sorquecod"] }],
             etatquestion: [{ name: "idx_etaquecod", columns: ["etaquecod"] }],
         },
+        rowMultisetMergeTables: ["tam_reponses"],
     },
     sens: {
         database: "sens",
@@ -213,12 +220,19 @@ export const datasets = {
                 { 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(EnabledDatasets[datasetName], undefined, `Unknown name of dataset: ${datasetName}`));
+    categories.map((datasetName) => assert.notStrictEqual(getEnabledDatasetByName(datasetName), undefined, `Unknown name of dataset: ${datasetName}`));
     return categories.reduce((enabledDatasets, datasetName) => {
-        const enabledDataset = EnabledDatasets[datasetName];
+        const enabledDataset = getEnabledDatasetByName(datasetName);
         return enabledDatasets | (enabledDataset || EnabledDatasets.None);
     }, EnabledDatasets.None);
 }

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>;