@tricoteuses/senat 1.1.1 → 1.3.1

package/lib/model/dosleg.ts

@@ -1,558 +1,240 @@
-import {
-  Ass, assFieldsToTrim,
-  Aud, audFieldsToTrim,
-  Auteur, auteurFieldsToTrim,
-  DateSeance, dateSeanceFieldsToTrim,
-  DecCoc, deccocFieldsToTrim,
-  DenRap, denrapFieldsToTrim,
-  DocAtt, docattFieldsToParseInt, docattFieldsToTrim,
-  Ecr, ecrFieldsToTrim,
-  EtaLoi, etaloiFieldsToTrim,
-  LecAss, lecassFieldsToTrim,
-  LecAssRap, lecassrapFieldsToTrim,
-  Lecture, lectureFieldsToTrim,
-  Loi, loiFieldsToTrim,
-  Org, orgFieldsToTrim,
-  OriTxt, oritxtFieldsToTrim,
-  Qua, quaFieldsToTrim,
-  Rap, rapFieldsToParseInt, rapFieldsToTrim,
-  RapOrg, raporgFieldsToTrim,
-  Scr, scrFieldsToTrim,
-  Texte, texteFieldsToParseInt, texteFieldsToTrim,
-  TypAtt, typattFieldsToTrim,
-  TypLec, typlecFieldsToTrim,
-  TypLoi, typloiFieldsToTrim,
-  TypTxt, typtxtFieldsToTrim,
-  TypUrl, typurlFieldsToTrim,
-} from '../types/dosleg'
-import { dbByName } from "../databases"
-import { parseIntFields, trimFieldsRight } from '../fields'
+import { Expression, InferResult, NotNull, sql } from "kysely"
+import { jsonArrayFrom } from "kysely/helpers/postgres"
 
-export const getAsss = async (ids: string[]): Promise<Ass[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM ass
-      WHERE codass IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((ass: Ass) => trimFieldsRight(assFieldsToTrim, ass))
-}
+import { dbDosleg } from "../databases"
+import { concat, removeSubstring, rtrim, toDateString } from "./util"
 
-export const getAudsFromLecassidts = async (ids: string[]): Promise<Aud[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM aud
-      WHERE lecassidt IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((aud: Aud) => trimFieldsRight(audFieldsToTrim, aud))
+function orderOrdreOrigineTexte (expr: Expression<string | null | undefined>) {
+  return sql`array_position(array['0','2','1'], ${expr})`
 }
 
-export const getAuteurs = async (ids: string[]): Promise<Auteur[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM auteur
-      WHERE autcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((auteur: Auteur) => trimFieldsRight(auteurFieldsToTrim, auteur))
-}
-
-export const getDatesSeancesFromLecassidts = async (
-  ids: string[],
-): Promise<DateSeance[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM date_seance
-      WHERE lecidt IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((dateSeance: DateSeance) =>
-    trimFieldsRight(dateSeanceFieldsToTrim, dateSeance),
+function datesSeances (lectureAssembleeId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("date_seance")
+      .where("date_seance.lecidt", "=", lectureAssembleeId)
+      .select(({ ref }) => [
+        toDateString(ref("date_seance.date_s")).as("date"),
+      ]),
   )
 }
 
-export const getDeccocs = async (ids: string[]): Promise<DecCoc[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM deccoc
-      WHERE deccoccod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((deccoc: DecCoc) => trimFieldsRight(deccocFieldsToTrim, deccoc))
-}
-
-export const getDenraps = async (ids: string[]): Promise<DenRap[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM denrap
-      WHERE coddenrap IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((denrap: DenRap) => trimFieldsRight(denrapFieldsToTrim, denrap))
-}
-
-export const getDocattsFromRapcods = async (
-  ids: string[],
-): Promise<DocAtt[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM docatt
-      WHERE rapcod IN($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((docatt: DocAtt) =>
-    parseIntFields(
-      docattFieldsToParseInt,
-      trimFieldsRight(docattFieldsToTrim, docatt),
-    ),
+function organismesRapport (rapportId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("org")
+      .leftJoin("raporg", "raporg.orgcod", "org.orgcod")
+      .where("raporg.rapcod", "=", rapportId)
+      .select([
+        "org.orgnom as libelle",
+      ]),
   )
 }
 
-export const getEcrsFromRapcods = async (ids: string[]): Promise<Ecr[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM ecr
-      WHERE rapcod IN($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((ecr: Ecr) => trimFieldsRight(ecrFieldsToTrim, ecr))
-}
-
-export const getEcrsFromTexcods = async (ids: string[]): Promise<Ecr[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM ecr
-      WHERE texcod IN($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((ecr: Ecr) => trimFieldsRight(ecrFieldsToTrim, ecr))
-}
-
-export const getEtalois = async (ids: string[]): Promise<EtaLoi[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM etaloi
-      WHERE etaloicod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((etaloi: EtaLoi) => trimFieldsRight(etaloiFieldsToTrim, etaloi))
-}
-
-export const getLecasssFromLecidts = async (
-  ids: string[],
-): Promise<LecAss[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM lecass
-      WHERE lecidt IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((lecass: LecAss) => trimFieldsRight(lecassFieldsToTrim, lecass))
-}
-
-export const getLecassrapsFromLecassidts = async (
-  ids: string[],
-): Promise<LecAssRap[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM lecassrap
-      WHERE lecassidt IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((lecassrap: LecAssRap) =>
-    trimFieldsRight(lecassrapFieldsToTrim, lecassrap),
+function auteursRapport (rapportId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("auteur")
+      .leftJoin("ecr", "ecr.autcod", "auteur.autcod")
+      .where("ecr.rapcod", "=", rapportId)
+      .select([
+        "auteur.prenom as prenom",
+        "auteur.nomuse as nom_usuel",
+        "auteur.autmat as matricule",
+      ])
+    .orderBy("ecr.ecrnumtri", "asc"),
   )
 }
 
-export const getLecturesFromLoicods = async (
-  ids: string[],
-): Promise<Lecture[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM lecture
-      WHERE loicod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((lecture: Lecture) => trimFieldsRight(lectureFieldsToTrim, lecture))
-}
-
-export const getLois = async (ids: string[]): Promise<Loi[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM loi
-      WHERE loicod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((loi: Loi) => trimFieldsRight(loiFieldsToTrim, loi))
-}
-
-export const getAllLois = async (): Promise<Loi[]> => {
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM loi
-    `
-    )
-  ).map((loi: Loi) => trimFieldsRight(loiFieldsToTrim, loi))
-}
-
-export const getOrgs = async (ids: string[]): Promise<Org[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM org
-      WHERE orgcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((org: Org) => trimFieldsRight(orgFieldsToTrim, org))
-}
-
-export const getOrgsFromRapcods = async (ids: string[]): Promise<Org[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM org
-      WHERE orgcod IN (
-        SELECT orgcod
-        FROM raporg
-        WHERE rapcod IN ($<ids:list>)
-      )
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((org: Org) => trimFieldsRight(orgFieldsToTrim, org))
-}
-
-export const getRaporgsFromOrgcods = async (ids: string[]): Promise<RapOrg[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM raporg
-      WHERE orgcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((raporg: RapOrg) => trimFieldsRight(raporgFieldsToTrim, raporg))
-}
-
-export const getOritxts = async (ids: string[]): Promise<OriTxt[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM oritxt
-      WHERE oritxtcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((oritxt: OriTxt) => trimFieldsRight(oritxtFieldsToTrim, oritxt))
-}
-
-export const getQuas = async (ids: string[]): Promise<Qua[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM qua
-      WHERE quacod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((qua: Qua) => trimFieldsRight(quaFieldsToTrim, qua))
-}
-
-export const getRaps = async (ids: string[]): Promise<Rap[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM rap
-      WHERE rapcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((rap: Rap) =>
-    parseIntFields(rapFieldsToParseInt, trimFieldsRight(rapFieldsToTrim, rap)),
+function rapports (lectureAssembleeId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("rap")
+      .leftJoin("lecassrap", "lecassrap.rapcod", "rap.rapcod")
+      .leftJoin("denrap", "denrap.coddenrap", "rap.coddenrap")
+      .where("lecassrap.lecassidt", "=", lectureAssembleeId)
+      .select(({ eb, ref, val }) => [
+        "rap.rapnum as numero",
+        rtrim(ref("denrap.libdenrap")).as("type_rapport"),
+        eb.case()
+          .when("rap.typurl", "=", "I")
+          .then(concat(val("https://www.senat.fr/rap/"), rtrim(ref("rap.rapurl"))))
+          .else(rtrim(ref("rap.rapurl")))
+          .end()
+          .as("url"),
+        toDateString(ref("rap.date_depot")).as("date_depot"),
+        auteursRapport(ref("rap.rapcod")).as("auteurs"),
+        organismesRapport(ref("rap.rapcod")).as("organismes"),
+      ]),
   )
 }
 
-export const getScrsFromCodes = async (ids: string[]): Promise<Scr[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM scr
-      WHERE code IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((scr: Scr) => trimFieldsRight(scrFieldsToTrim, scr))
-}
-
-export const getTextesFromLecassidts = async (
-  ids: string[],
-): Promise<Texte[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM texte
-      WHERE lecassidt IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((texte: Texte) =>
-    parseIntFields(
-      texteFieldsToParseInt,
-      trimFieldsRight(texteFieldsToTrim, texte),
-    ),
+function auteursTexte (texteId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("auteur")
+      .leftJoin("ecr", "ecr.autcod", "auteur.autcod")
+      .where("ecr.texcod", "=", texteId)
+      .select([
+        "auteur.prenom as prenom",
+        "auteur.nomuse as nom_usuel",
+        "auteur.autmat as matricule",
+      ])
+    .orderBy("ecr.ecrnumtri", "asc"),
   )
 }
 
-export const getTypatts = async (ids: string[]): Promise<TypAtt[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM typatt
-      WHERE typattcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((typatt: TypAtt) => trimFieldsRight(typattFieldsToTrim, typatt))
+function textes (lectureAssembleeId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("texte")
+      .leftJoin("oritxt", "oritxt.oritxtcod", "texte.oritxtcod")
+      .leftJoin("typtxt", "typtxt.typtxtcod", "texte.typtxtcod")
+      .where("texte.lecassidt", "=", lectureAssembleeId)
+      .select(({ eb, ref, val }) => [
+        "texte.texnum as numero",
+        eb.case()
+          .when("texte.typurl", "=", "I")
+          .then(removeSubstring(ref("texte.texurl"), val(".html")))
+          .else(null)
+          .end()
+          .as("id"),
+        eb.case()
+          .when("texte.typurl", "=", "I")
+          .then(concat(val("https://www.senat.fr/leg/"), rtrim(ref("texte.texurl"))))
+          .else(rtrim(ref("texte.texurl")))
+          .end()
+          .as("url"),
+        rtrim(ref("oritxt.oritxtlib")).as("origine_texte"),
+        rtrim(ref("typtxt.typtxtlib")).as("type_texte"),
+        toDateString(ref("texte.txtoritxtdat")).as("date"),
+        "sesann as session",
+        auteursTexte(ref("texte.texcod")).as("auteurs"),
+      ])
+      .orderBy(({ ref }) => orderOrdreOrigineTexte(ref("oritxt.oriordre")))
+  )
 }
 
-export const getTyplecs = async (ids: string[]): Promise<TypLec[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM typlec
-      WHERE typleccod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((typlec: TypLec) => trimFieldsRight(typlecFieldsToTrim, typlec))
+function lecturesAssemblee (lectureId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("lecass")
+      .where("lecass.lecidt", "=", lectureId)
+      .leftJoin("ass", "ass.codass", "lecass.codass")
+      .leftJoin("org", "org.orgcod", "lecass.orgcod")
+      .select(({ ref }) => [
+        rtrim(ref("ass.libass")).as("assemblee"),
+        "org.orgnom as libelle_organisme",
+        "org.orgcod as code_organisme",
+        "lecass.ordreass as ordre_lecture_assemblee",
+        textes(ref("lecass.lecassidt")).as("textes"),
+        rapports(ref("lecass.lecassidt")).as("rapports"),
+        datesSeances(ref("lecass.lecassidt")).as("dates_seances"),
+      ])
+      .orderBy("lecass.ordreass", "asc"),
+  )
 }
 
-export const getTyplois = async (ids: string[]): Promise<TypLoi[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM typloi
-      WHERE typloicod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((typloi: TypLoi) => trimFieldsRight(typloiFieldsToTrim, typloi))
+function lectures (loiId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("lecture")
+      .leftJoin("typlec", "typlec.typleccod", "lecture.typleccod")
+      .where("lecture.loicod", "=", loiId)
+      .select(({ ref }) => [
+        rtrim(ref("typlec.typleclib")).as("type_lecture"),
+        rtrim(ref("lecture.leccom")).as("libelle"),
+        "typlec.typlecord as ordre_lecture",
+        lecturesAssemblee(ref("lecture.lecidt")).as("lectures_assemblee"),
+      ])
+      .orderBy("typlec.typlecord", "asc"),
+  )
 }
 
-export const getTyptxts = async (ids: string[]): Promise<TypTxt[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM typtxt
-      WHERE typtxtcod IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((typtxt: TypTxt) => trimFieldsRight(typtxtFieldsToTrim, typtxt))
+function themes (loiId: Expression<string>) {
+  return jsonArrayFrom(
+    dbDosleg.selectFrom("the")
+      .leftJoin("loithe", "loithe.thecle", "the.thecle")
+      .where("loithe.loicod", "=", loiId)
+      .select([
+        "the.thelib as libelle",
+      ]),
+  )
 }
 
-export const getTypurls = async (ids: string[]): Promise<TypUrl[]> => {
-  if (ids.length === 0) {
-    return []
-  }
-  return (
-    await dbByName.dosleg.any(
-      `
-      SELECT *
-      FROM typurl
-      WHERE typurl IN ($<ids:list>)
-    `,
-      {
-        ids,
-      },
-    )
-  ).map((typurl: TypUrl) => trimFieldsRight(typurlFieldsToTrim, typurl))
-}
+const findAllQuery = dbDosleg
+  .selectFrom("loi")
+  .leftJoin("typloi", "typloi.typloicod", "loi.typloicod")
+  .leftJoin("etaloi", "etaloi.etaloicod", "loi.etaloicod")
+  .select(({ eb, ref, val }) => [
+    "loi.signet as signet",
+    concat(val("https://www.senat.fr/dossier-legislatif/"), ref("loi.signet"), val(".html")).as("url"),
+    concat(rtrim(ref("typloi.typloiden")), val(" "), rtrim(ref("loi.loitit"))).as("titre"),
+    rtrim(ref("loi.loient")).as("titre_court"),
+    rtrim(ref("typloi.groupe")).as("code_nature_dossier"),
+    rtrim(ref("typloi.typloilib")).as("libelle_type_dossier"),
+    rtrim(ref("etaloi.etaloilib")).as("etat_dossier"),
+    "loi.url_an as url_dossier_assemblee_nationale",
+    toDateString(ref("loi.date_decision")).as("date_decision_CoC"),
+    "loi.num_decision as num_decision_CoC",
+    "loi.deccocurl as url_decision_CoC",
+    toDateString(ref("loi.saisine_date")).as("date_saisine_CoC"),
+    "loi.saisine_par as condition_saisine_CoC",
+    toDateString(ref("loi.date_loi")).as("date_promulgation"),
+    "loi.numero as numero_loi",
+    eb.case()
+      .when("loi.loititjo", "is not", null)
+      .then(concat(rtrim(ref("typloi.typloiden")), val(" "), rtrim(ref("loi.loititjo"))))
+      .else("")
+      .end()
+      .as("titre_JO"),
+    toDateString(ref("loi.loidatjo")).as("date_publication_JO"),
+    "loi.loinumjo as numero_JO",
+    "loi.url_jo as url_JO",
+    lectures(ref("loi.loicod")).as("lectures"),
+    themes(ref("loi.loicod")).as("themes"),
+  ])
+  .$narrowType<{ signet: NotNull }>()
+
+export function findAll () {
+  return findAllQuery.stream()
+}
+
+export function findSenatTexteUrls (sessions: string[] = []): AsyncIterableIterator<{
+  session: string | null | undefined,
+  url: string,
+  hasExposeDesMotifs: boolean,
+}> {
+  return dbDosleg
+    .selectFrom("texte")
+    .where("texurl", "is not", null)
+    .where("typurl", "=", "I")
+    .$if(sessions.length > 0, (qb) => qb
+      .where("sesann", "in", sessions),
+    )
+    .select(({ eb, ref }) => [
+      "sesann as session",
+      rtrim(ref("texurl")).as("url"),
+      eb.case()
+        .when("oritxtcod", "=", "1")
+        .then(true)
+        .else(false)
+        .end()
+        .as("hasExposeDesMotifs"),
+    ])
+    .$narrowType<{ url: NotNull }>()
+    .stream()
+}
+
+export function findSenatRapportUrls (sessions: string[] = []): AsyncIterableIterator<{
+  url: string,
+  session: string | null | undefined
+}> {
+  return dbDosleg
+    .selectFrom("rap")
+    .where("rapurl", "is not", null)
+    .where("typurl", "=", "I")
+    .$if(sessions.length > 0, (qb) => qb
+      .where("sesann", "in", sessions),
+    )
+    .select(({ ref }) => [
+      rtrim(ref("rapurl")).as("url"),
+      "sesann as session",
+    ])
+    .$narrowType<{ url: NotNull }>()
+    .stream()
+}
+
+export type DossierLegislatifResult = InferResult<typeof findAllQuery>[0]