@tricoteuses/senat 1.1.1 → 1.3.1

package/lib/src/inserters.mjs

@@ -0,0 +1,360 @@
+export function insertAudReferences(aud, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.aud;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.aud = new Set();
+    }
+    if (!visitedIds.has(aud.audcle)) {
+        visitedIds.add(aud.audcle);
+        if (aud.orgcod !== null && data.org !== undefined) {
+            const org = data.org[aud.orgcod];
+            if (org !== undefined) {
+                aud.org = org;
+                // insertOrgReferences(org, data, visitedIdsByTableName)
+            }
+        }
+        // TODO
+    }
+    return aud;
+}
+export function insertAuteurReferences(auteur, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.auteur;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.auteur = new Set();
+    }
+    if (!visitedIds.has(auteur.autcod)) {
+        visitedIds.add(auteur.autcod);
+        if (data.qua !== undefined) {
+            const qua = data.qua[auteur.quacod];
+            if (qua !== undefined) {
+                auteur.qua = qua;
+                // insertQuaReferences(qua, data, visitedIdsByTableName)
+            }
+        }
+        // TODO
+    }
+    return auteur;
+}
+export function insertDateSeanceReferences(dateSeance, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.date_seance;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.date_seance = new Set();
+    }
+    if (!visitedIds.has(dateSeance.code)) {
+        visitedIds.add(dateSeance.code);
+        if (dateSeance.date_s !== null && data.debats !== undefined) {
+            const dateString = dateSeance.date_s instanceof Date
+                ? dateSeance.date_s.toISOString()
+                : dateSeance.date_s;
+            const debat = data.debats[dateString];
+            if (debat !== undefined) {
+                dateSeance.debat = debat;
+                // insertDebatReferences(debat, data, visitedIdsByTableName)
+            }
+        }
+        dateSeance.scrs = [];
+        if (dateSeance.scrids !== undefined && data.scr !== undefined) {
+            for (const scrid of dateSeance.scrids) {
+                const scr = data.scr[scrid];
+                if (scr !== undefined) {
+                    dateSeance.scrs.push(scr);
+                    // insertScrReferences(scr, data, visitedIdsByTableName)
+                }
+            }
+        }
+    }
+    return dateSeance;
+}
+export function insertDocAttReferences(docatt, data, visitedIdsByTableName, performInsertRapReferences = true) {
+    let visitedIds = visitedIdsByTableName.docatt;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.docatt = new Set();
+    }
+    if (!visitedIds.has(docatt.docattcle)) {
+        visitedIds.add(docatt.docattcle);
+        if (performInsertRapReferences && docatt.rapcod !== null && data.rap !== undefined) {
+            const rap = data.rap[docatt.rapcod];
+            if (rap !== undefined) {
+                docatt.rap = rap;
+                insertRapReferences(rap, data, visitedIdsByTableName);
+            }
+        }
+        if (docatt.typattcod !== null && data.typatt !== undefined) {
+            const typatt = data.typatt[docatt.typattcod];
+            if (typatt !== undefined) {
+                docatt.typatt = typatt;
+                // insertTypAttReferences(typatt, data, visitedIdsByTableName)
+            }
+        }
+    }
+    return docatt;
+}
+export function insertEcrReferences(ecr, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.ecr;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.ecr = new Set();
+    }
+    if (!visitedIds.has(ecr.ecrnum)) {
+        visitedIds.add(ecr.ecrnum);
+        if (ecr.autcod !== null && data.auteur !== undefined) {
+            const aut = data.auteur[ecr.autcod];
+            if (aut !== undefined) {
+                ecr.aut = aut;
+                insertAuteurReferences(aut, data, visitedIdsByTableName);
+            }
+        }
+        // TODO
+    }
+    return ecr;
+}
+export function insertLecassrapReferences(lecassrap, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.lecassrap;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.lecassrap = new Set();
+    }
+    const lecasrapid = `${lecassrap.lecassidt} ${lecassrap.rapcod}`;
+    if (!visitedIds.has(lecasrapid)) {
+        visitedIds.add(lecasrapid);
+        if (lecassrap.rapcod !== null && data.rap !== undefined) {
+            const rap = data.rap[lecassrap.rapcod];
+            if (rap !== undefined) {
+                lecassrap.rap = rap;
+                insertRapReferences(rap, data, visitedIdsByTableName);
+            }
+        }
+    }
+    return lecassrap;
+}
+export function insertLecassReferences(lecass, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.lecass;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.lecass = new Set();
+    }
+    if (!visitedIds.has(lecass.lecassidt)) {
+        visitedIds.add(lecass.lecassidt);
+        if (lecass.codass !== null && data.ass !== undefined) {
+            const ass = data.ass[lecass.codass];
+            if (ass !== undefined) {
+                lecass.ass = ass;
+                // insertAssReferences(ass, data, visitedIdsByTableName)
+            }
+        }
+        if (lecass.orgcod !== null && data.org !== undefined) {
+            const org = data.org[lecass.orgcod];
+            if (org !== undefined) {
+                lecass.org = org;
+                // insertOrgReferences(org, data, visitedIdsByTableName)
+            }
+        }
+        lecass.auds = [];
+        if (lecass.audcles !== undefined && data.aud !== undefined) {
+            for (const audcle of lecass.audcles) {
+                const aud = data.aud[audcle];
+                if (aud !== undefined) {
+                    lecass.auds.push(aud);
+                    insertAudReferences(aud, data, visitedIdsByTableName);
+                }
+            }
+        }
+        lecass.datesSeances = [];
+        if (lecass.datesSeancesCodes !== undefined && data.date_seance !== undefined) {
+            for (const dateSeanceCode of lecass.datesSeancesCodes) {
+                const dateSeance = data.date_seance[dateSeanceCode];
+                if (dateSeance !== undefined) {
+                    lecass.datesSeances.push(dateSeance);
+                    insertDateSeanceReferences(dateSeance, data, visitedIdsByTableName);
+                }
+            }
+        }
+        lecass.lecassraps = [];
+        if (lecass.lecassrapids !== undefined && data.lecassrap !== undefined) {
+            for (const lecassrapid of lecass.lecassrapids) {
+                const lecassrap = data.lecassrap[lecassrapid];
+                if (lecassrap !== undefined) {
+                    lecass.lecassraps.push(lecassrap);
+                    insertLecassrapReferences(lecassrap, data, visitedIdsByTableName);
+                }
+            }
+        }
+        lecass.textes = [];
+        if (lecass.texcods !== undefined && data.texte !== undefined) {
+            for (const texcod of lecass.texcods) {
+                const texte = data.texte[texcod];
+                if (texte !== undefined) {
+                    lecass.textes.push(texte);
+                    insertTexteReferences(texte, data, visitedIdsByTableName);
+                }
+            }
+        }
+    }
+    return lecass;
+}
+export function insertLectureReferences(lecture, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.lecture;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.lecture = new Set();
+    }
+    if (!visitedIds.has(lecture.lecidt)) {
+        visitedIds.add(lecture.lecidt);
+        if (lecture.typleccod !== null && data.typlec !== undefined) {
+            const typlec = data.typlec[lecture.typleccod];
+            if (typlec !== undefined) {
+                lecture.typlec = typlec;
+                // insertTyplecReferences(typlec, data, visitedIdsByTableName)
+            }
+        }
+        lecture.lecasss = [];
+        if (lecture.lecassidts !== undefined && data.lecass !== undefined) {
+            for (const lecassidt of lecture.lecassidts) {
+                const lecass = data.lecass[lecassidt];
+                if (lecass !== undefined) {
+                    lecture.lecasss.push(lecass);
+                    insertLecassReferences(lecass, data, visitedIdsByTableName);
+                }
+            }
+        }
+    }
+    return lecture;
+}
+export function insertLoiReferences(loi, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.loi;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.loi = new Set();
+    }
+    if (!visitedIds.has(loi.loicod)) {
+        visitedIds.add(loi.loicod);
+        if (loi.typloicod !== null && data.typloi !== undefined) {
+            const typloi = data.typloi[loi.typloicod];
+            if (typloi !== undefined) {
+                loi.typloi = typloi;
+                // insertTyploiReferences(typloi, data, visitedIdsByTableName)
+            }
+        }
+        if (loi.etaloicod !== null && data.etaloi !== undefined) {
+            const etaloi = data.etaloi[loi.etaloicod];
+            if (etaloi !== undefined) {
+                loi.etaloi = etaloi;
+                // insertEtaloiReferences(etaloi, data, visitedIdsByTableName)
+            }
+        }
+        if (loi.deccoccod !== null && data.deccoc !== undefined) {
+            const deccoc = data.deccoc[loi.deccoccod];
+            if (deccoc !== undefined) {
+                loi.deccoc = deccoc;
+                // insertDeccocReferences(deccoc, data, visitedIdsByTableName)
+            }
+        }
+        loi.lectures = [];
+        if (loi.lecidts !== undefined && data.lecture !== undefined) {
+            for (const lecidt of loi.lecidts) {
+                const lecture = data.lecture[lecidt];
+                if (lecture !== undefined) {
+                    loi.lectures.push(lecture);
+                    insertLectureReferences(lecture, data, visitedIdsByTableName);
+                }
+            }
+        }
+    }
+    return loi;
+}
+export function insertRapReferences(rap, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.rap;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.rap = new Set();
+    }
+    if (!visitedIds.has(rap.rapcod)) {
+        visitedIds.add(rap.rapcod);
+        if (rap.coddenrap !== null && data.denrap !== undefined) {
+            const denrap = data.denrap[rap.coddenrap];
+            if (denrap !== undefined) {
+                rap.denrap = denrap;
+                // insertDenrapReferences(denrap, data, visitedIdsByTableName)
+            }
+        }
+        rap.docatts = [];
+        if (rap.docattcles !== undefined && data.docatt !== undefined) {
+            for (const docattcle of rap.docattcles) {
+                const docatt = data.docatt[docattcle];
+                if (docatt !== undefined) {
+                    rap.docatts.push(docatt);
+                    insertDocAttReferences(docatt, data, visitedIdsByTableName, false);
+                }
+            }
+        }
+        rap.ecrs = [];
+        if (rap.ecrnums !== undefined && data.ecr !== undefined) {
+            for (const ecrnum of rap.ecrnums) {
+                const ecr = data.ecr[ecrnum];
+                if (ecr !== undefined) {
+                    rap.ecrs.push(ecr);
+                    insertEcrReferences(ecr, data, visitedIdsByTableName);
+                }
+            }
+        }
+        rap.orgs = [];
+        if (rap.orgcods !== undefined && data.org !== undefined) {
+            for (const orgcod of rap.orgcods) {
+                const org = data.org[orgcod];
+                if (org !== undefined) {
+                    rap.orgs.push(org);
+                    // insertOrgReferences(org, data, visitedIdsByTableName)
+                }
+            }
+        }
+    }
+    return rap;
+}
+export function insertTexteReferences(texte, data, visitedIdsByTableName) {
+    let visitedIds = visitedIdsByTableName.texte;
+    if (visitedIds === undefined) {
+        visitedIds = visitedIdsByTableName.texte = new Set();
+    }
+    if (!visitedIds.has(texte.texcod)) {
+        visitedIds.add(texte.texcod);
+        texte.ecrs = [];
+        if (texte.ecrnums !== undefined && data.ecr !== undefined) {
+            for (const ecrnum of texte.ecrnums) {
+                const ecr = data.ecr[ecrnum];
+                if (ecr !== undefined) {
+                    texte.ecrs.push(ecr);
+                    insertEcrReferences(ecr, data, visitedIdsByTableName);
+                }
+            }
+        }
+        if (texte.orgcod !== null && data.org !== undefined) {
+            const org = data.org[texte.orgcod];
+            if (org !== undefined) {
+                texte.org = org;
+                // insertOrgReferences(org, data, visitedIdsByTableName)
+            }
+        }
+        if (texte.oritxtcod !== null && data.oritxt !== undefined) {
+            const oritxt = data.oritxt[texte.oritxtcod];
+            if (oritxt !== undefined) {
+                texte.oritxt = oritxt;
+                // insertOritxtReferences(oritxt, data, visitedIdsByTableName)
+            }
+        }
+        if (texte.txtAmeliId !== undefined && data.txt_ameli !== undefined) {
+            const txtAmeli = data.txt_ameli[texte.txtAmeliId];
+            if (txtAmeli !== undefined) {
+                texte.txtAmeli = txtAmeli;
+            }
+        }
+        if (texte.typtxtcod !== null && data.typtxt !== undefined) {
+            const typtxt = data.typtxt[texte.typtxtcod];
+            if (typtxt !== undefined) {
+                texte.typtxt = typtxt;
+                // insertTyptxtReferences(typtxt, data, visitedIdsByTableName)
+            }
+        }
+        if (texte.typurl !== null && data.typurl !== undefined) {
+            const typurl = data.typurl[texte.typurl];
+            if (typurl !== undefined) {
+                texte.libtypurl = typurl.libtypurl;
+                // insertTypurlReferences(typurl, data, visitedIdsByTableName)
+            }
+        }
+        // TODO
+    }
+    return texte;
+}

package/lib/src/loaders.d.ts

@@ -0,0 +1,36 @@
+import { DossierLegislatifResult } from "./model/dosleg";
+import { QuestionResult } from "./model/questions";
+import { CirconscriptionResult, SenateurResult } from "./model/sens";
+import { FlatTexte } from "./types/texte";
+export { EnabledDatasets } from "./datasets";
+type IterItem<T> = {
+    item: T;
+    filePathFromDataset?: string;
+    legislature?: number;
+};
+export interface DossierLegislatifTexteResult {
+    signet_dossier: string;
+    url_dossier_senat: string;
+    url_dossier_assemblee_nationale: string | null;
+    type_lecture: string;
+    libelle_lecture: string;
+    libelle_organisme: string | null;
+    numero: string | null;
+    url: string;
+    origine_texte: string;
+    type_texte: string;
+    date: Date;
+    session: string | null;
+    auteurs: {
+        prenom: string | null;
+        nom_usuel: string;
+        matricule: string | null;
+    }[];
+}
+export declare function iterFilePaths(dirPath: string): Generator<string>;
+export declare function iterLoadSenatDossiersLegislatifs(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<DossierLegislatifResult>>;
+export declare function iterLoadSenatDossiersLegislatifsTextes(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<DossierLegislatifTexteResult>>;
+export declare function loadSenatTexteContent(dataDir: string, textePathFromDataset: string): IterItem<FlatTexte | null>;
+export declare function iterLoadSenatSenateurs(dataDir: string, legislature: number, options?: {}): Generator<IterItem<SenateurResult>>;
+export declare function iterLoadSenatCirconscriptions(dataDir: string, options?: {}): Generator<IterItem<CirconscriptionResult>>;
+export declare function iterLoadSenatQuestions(dataDir: string, legislature: number, options?: {}): Generator<IterItem<QuestionResult>>;

package/lib/src/loaders.mjs

@@ -0,0 +1,107 @@
+import fs from "fs";
+import path from "path";
+import legislatures from "../data/legislatures.json";
+import { datasets } from "./datasets";
+import { UNDEFINED_SESSION } from "./scripts/datautil";
+export { EnabledDatasets } from "./datasets";
+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, dataset, legislatureOrSession, subDir, { log = false } = {}) {
+    let itemsDir = path.join(dataDir, dataset.database);
+    if (legislatureOrSession) {
+        itemsDir = path.join(itemsDir, String(legislatureOrSession));
+    }
+    if (subDir) {
+        itemsDir = path.join(itemsDir, subDir);
+    }
+    for (const filePath of iterFilePaths(itemsDir)) {
+        if (log) {
+            console.log(`Loading file: ${filePath}…`);
+        }
+        const itemJson = fs.readFileSync(filePath, { encoding: "utf8" });
+        const item = JSON.parse(itemJson);
+        const filePathFromDataset = filePath.substring(filePath.indexOf(dataset.database) + dataset.database.length);
+        yield {
+            item,
+            filePathFromDataset,
+            legislature: legislatureOrSession,
+        };
+    }
+}
+export function* iterLoadSenatDossiersLegislatifs(dataDir, session, options = {}) {
+    for (const dossierLegislatifItem of iterLoadSenatItems(dataDir, datasets.dosleg, session, undefined, options)) {
+        yield dossierLegislatifItem;
+    }
+}
+export function* iterLoadSenatDossiersLegislatifsTextes(dataDir, session, 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 texte of lectureSenat.textes) {
+                    const enrichedTexte = {
+                        signet_dossier: dossierLegislatif.signet,
+                        url_dossier_senat: dossierLegislatif.url,
+                        url_dossier_assemblee_nationale: dossierLegislatif.url_dossier_assemblee_nationale,
+                        type_lecture: lecture.type_lecture,
+                        libelle_lecture: lecture.libelle,
+                        libelle_organisme: lectureSenat.libelle_organisme,
+                        ...texte,
+                    };
+                    const texteItem = {
+                        item: enrichedTexte,
+                    };
+                    if (texte.url) {
+                        const texteName = path.parse(texte.url).name;
+                        texteItem.filePathFromDataset
+                            = path.join(`${texte.session ?? UNDEFINED_SESSION}`, texteName, `${texteName}.pdf`);
+                    }
+                    yield texteItem;
+                }
+            }
+        }
+    }
+}
+export function loadSenatTexteContent(dataDir, textePathFromDataset) {
+    const parsedTextePath = path.parse(textePathFromDataset);
+    const jsonTexteName = `${parsedTextePath.name}.akn.json`;
+    const fullTextePath = path.join(dataDir, "leg", "transformed", parsedTextePath.dir, jsonTexteName);
+    if (!fs.existsSync(fullTextePath)) {
+        return { item: null };
+    }
+    const texteJson = fs.readFileSync(fullTextePath, { encoding: "utf8" });
+    return { item: JSON.parse(texteJson) };
+}
+export function* iterLoadSenatSenateurs(dataDir, legislature, options = {}) {
+    const dateDebutLegislatureStr = legislatures
+        .find(legislatureInfo => legislatureInfo.numero === legislature)
+        ?.date_debut;
+    const dateDebutLegislature = new Date(dateDebutLegislatureStr);
+    for (const senateurItem of iterLoadSenatItems(dataDir, datasets.sens, undefined, "sens", options)) {
+        const dateFinMandatSenateur = senateurItem.item.mandats_senateur[0]?.date_fin ?
+            new Date(senateurItem.item.mandats_senateur[0]?.date_fin) : null;
+        if (dateFinMandatSenateur && dateFinMandatSenateur < dateDebutLegislature) {
+            continue;
+        }
+        yield senateurItem;
+    }
+}
+export function* iterLoadSenatCirconscriptions(dataDir, options = {}) {
+    for (const circonscriptionItem of iterLoadSenatItems(dataDir, datasets.sens, undefined, "circonscriptions", options)) {
+        yield circonscriptionItem;
+    }
+}
+export function* iterLoadSenatQuestions(dataDir, legislature, options = {}) {
+    for (const questionItem of iterLoadSenatItems(dataDir, datasets.questions, legislature, undefined, options)) {
+        yield questionItem;
+    }
+}

package/lib/src/model/ameli.d.ts

@@ -0,0 +1,4 @@
+import { Ses, Sub, TxtAmeli } from "../types/ameli";
+export declare const getSessFromAnns: (ids: string[]) => Promise<Ses[]>;
+export declare const getSubsFromTxtids: (ids: string[]) => Promise<Sub[]>;
+export declare const getTxtsAmeliBySesannNumJoins: (ids: string[]) => Promise<TxtAmeli[]>;

package/lib/src/model/ameli.js

@@ -0,0 +1,57 @@
+import { sesFieldsToParseInt, sesFieldsToTrim, subFieldsToParseInt, subFieldsToTrim, txtAmeliFieldsToTrim, } from "../types/ameli";
+import { dbByName } from "../databases";
+import { parseIntFields, trimFieldsRight } from "../fields";
+export const getSessFromAnns = async (ids) => {
+    if (ids.length === 0) {
+        return [];
+    }
+    return (await dbByName.ameli.any(`
+      SELECT *
+      FROM ses
+      WHERE ann IN ($<ids:list>)
+    `, {
+        ids,
+    })).map((ses) => parseIntFields(sesFieldsToParseInt, trimFieldsRight(sesFieldsToTrim, ses)));
+};
+export const getSubsFromTxtids = async (ids) => {
+    if (ids.length === 0) {
+        return [];
+    }
+    return (await dbByName.ameli.any(`
+      SELECT *
+      FROM sub
+      WHERE txtid IN($<ids:list>)
+    `, {
+        ids,
+    })).map((sub) => parseIntFields(subFieldsToParseInt, trimFieldsRight(subFieldsToTrim, sub)));
+};
+export const getTxtsAmeliBySesannNumJoins = async (ids) => {
+    if (ids.length === 0) {
+        return [];
+    }
+    const txtsAmelis = [];
+    for (const id of ids) {
+        const idSplit = id.split(" ");
+        const sesann = parseInt(idSplit[0]);
+        const num = idSplit[1];
+        const txtAmeli = trimFieldsRight(txtAmeliFieldsToTrim, await dbByName.ameli.oneOrNone(`
+          SELECT *
+          FROM txt_ameli
+          WHERE
+            sesinsid in (
+              SELECT id
+              FROM ses
+              WHERE ann = $<sesann>
+            ) AND
+            num = $<num>
+          LIMIT 1
+        `, {
+            num,
+            sesann,
+        }));
+        if (txtAmeli !== null) {
+            txtsAmelis.push(txtAmeli);
+        }
+    }
+    return txtsAmelis;
+};

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

@@ -0,0 +1,4 @@
+import { Debat, LecAssDeb } from "../types/debats";
+export declare const getDebats: (ids: string[]) => Promise<Debat[]>;
+export declare const getDebatsFromLecassidts: (ids: string[]) => Promise<Debat[]>;
+export declare const getLecAssDebsFromDatseas: (ids: string[]) => Promise<LecAssDeb[]>;

package/lib/src/model/debats.js

@@ -0,0 +1,43 @@
+import { debatsFieldsToTrim, lecassdebFieldsToTrim, } from "../types/debats";
+import { dbByName } from "../databases";
+import { trimFieldsRight } from "../fields";
+export const getDebats = async (ids) => {
+    if (ids.length === 0) {
+        return [];
+    }
+    return (await dbByName.debats.any(`
+      SELECT *
+      FROM debats
+      WHERE datsea IN ($<ids:list>)
+    `, {
+        ids,
+    })).map((debat) => trimFieldsRight(debatsFieldsToTrim, debat));
+};
+export const getDebatsFromLecassidts = async (ids) => {
+    if (ids.length === 0) {
+        return [];
+    }
+    return (await dbByName.debats.any(`
+      SELECT *
+      FROM debats
+      WHERE datsea IN (
+        SELECT datsea
+        FROM lecassdeb
+        WHERE lecassidt IN ($<ids:list>)
+      )
+    `, {
+        ids,
+    })).map((debat) => trimFieldsRight(debatsFieldsToTrim, debat));
+};
+export const getLecAssDebsFromDatseas = async (ids) => {
+    if (ids.length === 0) {
+        return [];
+    }
+    return (await dbByName.debats.any(`
+      SELECT *
+      FROM lecassdeb
+      WHERE datsea IN ($<ids:list>)
+    `, {
+        ids,
+    })).map((lecassdeb) => trimFieldsRight(lecassdebFieldsToTrim, lecassdeb));
+};