@tekkare/romulus 0.1.240 → 0.1.242

package/layer/server/api/oip/metadata.patch.ts

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import { defineEventHandler } from "h3";
+import {
+  assertOipSuperAdmin,
+  oipAppUrls,
+  oipCheckRateLimit,
+  oipClientIp,
+  oipValidateBody,
+} from "../../utils/oipGuards";
+
+/**
+ * PATCH /api/oip/metadata, servi par le layer OIP.
+ *
+ * Correction des metadonnees de cette app depuis le panneau « Métadonnées »
+ * du rail : la fiche `OipApplication`, ou l'un de ses `OipSubject`.
+ *
+ * Meme forme que la correction des sources et des notes : le droit est celui
+ * de la console d'OIP 7, revalide ici et pas seulement a l'affichage du
+ * crayon, et le jeton Directus d'ecriture reste cote serveur.
+ *
+ * La cible n'est jamais prise au mot : la fiche corrigee est celle dont le
+ * `prod_url` est celui de cette app, relue ici, et un sujet ne se corrige que
+ * s'il lui appartient. Les deux collections sont communes a tout le portail,
+ * un id d'une autre app ne doit pas passer.
+ *
+ * Un champ absent du corps n'est pas efface. Une traduction absente est
+ * creee, une traduction existante est corrigee.
+ */
+
+const LANGUAGES = ["fr-FR", "en-US"] as const;
+const STATUSES = ["published", "draft", "archived", "ai_generated"] as const;
+
+const translation = z.object({
+  id: z.number().int().positive().optional(),
+  languages_code: z.enum(LANGUAGES),
+  name: z.string().max(300).optional(),
+  description: z.string().max(20000).nullable().optional(),
+});
+
+const schema = z
+  .object({
+    application: z
+      .object({
+        status: z.enum(STATUSES).optional(),
+        prod_url: z.string().url().max(500).optional(),
+        staging_url: z.string().url().max(500).nullable().optional(),
+        github_front_url: z.string().url().max(500).nullable().optional(),
+        categories: z.array(z.string().max(100)).max(30).optional(),
+        translations: z.array(translation).max(LANGUAGES.length).optional(),
+      })
+      .optional(),
+    subject: z
+      .object({
+        id: z.string().uuid(),
+        status: z.enum(STATUSES).optional(),
+        relative_path: z.string().max(300).optional(),
+        keywords: z.string().max(5000).nullable().optional(),
+        is_specialized_report: z.boolean().optional(),
+        translations: z.array(translation).max(LANGUAGES.length).optional(),
+      })
+      .optional(),
+  })
+  .refine((body) => body.application || body.subject, { message: "nothing to update" });
+
+export default defineEventHandler(async (event) => {
+  oipCheckRateLimit(`metadata-write:${oipClientIp(event)}`, 30, 15 * 60 * 1000);
+
+  await assertOipSuperAdmin(event);
+  const appUrl = oipAppUrls()[0];
+
+  const body = await oipValidateBody(event, schema);
+  const config = useRuntimeConfig();
+
+  const base = (config.directusSourcesWriteUrl as string | undefined)?.replace(/\/$/, "");
+  const token = config.directusMetadataWriteToken as string | undefined;
+  const readUrl = (config.directusNotesUrl as string | undefined)?.replace(/\/+$/, "");
+  const readToken = config.directusNotesToken as string | undefined;
+  if (!base || !token || !readUrl || !readToken) {
+    throw createError({ status: 500, message: "Directus write credentials are not configured" });
+  }
+
+  const write = (method: "PATCH" | "POST", path: string, payload: Record<string, unknown>) =>
+    $fetch(`${base}${path}`, {
+      method,
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: payload,
+    }).catch((err: any) => {
+      const reason = err?.data?.errors?.[0]?.message || err?.message || "unknown error";
+      throw createError({ status: 502, message: `Directus update failed: ${reason}` });
+    });
+
+  const defined = (input: Record<string, unknown>) =>
+    Object.fromEntries(Object.entries(input).filter(([, v]) => v !== undefined));
+
+  const upsertTranslations = async (
+    rows: z.infer<typeof translation>[] | undefined,
+    collection: string,
+    parentColumn: string,
+    parentId: string,
+    nameColumn: string,
+    descriptionColumn: string
+  ) => {
+    for (const row of rows ?? []) {
+      const payload = defined({ [nameColumn]: row.name, [descriptionColumn]: row.description });
+      if (!Object.keys(payload).length) continue;
+      if (row.id) {
+        await write("PATCH", `/items/${collection}/${row.id}`, payload);
+      } else {
+        await write("POST", `/items/${collection}`, {
+          ...payload,
+          [parentColumn]: parentId,
+          languages_code: row.languages_code,
+        });
+      }
+    }
+  };
+
+  // L'app de ce portail, relue : c'est elle et elle seule qu'on corrige.
+  const apps = await $fetch<{ data: { app_id: string }[] }>(`${readUrl}/items/OipApplication`, {
+    headers: { Authorization: `Bearer ${readToken}`, "Cache-Control": "no-store" },
+    query: { limit: 1, filter: JSON.stringify({ prod_url: { _eq: appUrl } }), fields: "app_id" },
+  });
+  const appId = apps.data?.[0]?.app_id;
+  if (!appId) throw createError({ status: 404, message: "Application not found in Directus" });
+
+  if (body.application) {
+    const { translations, ...rest } = body.application;
+    const fields = defined(rest);
+    if (Object.keys(fields).length) await write("PATCH", `/items/OipApplication/${appId}`, fields);
+    await upsertTranslations(
+      translations,
+      "OipApplication_translations",
+      "OipApplication_app_id",
+      appId,
+      "application_name",
+      "application_description"
+    );
+  }
+
+  if (body.subject) {
+    const { id, translations, keywords, ...rest } = body.subject;
+    const subject = await $fetch<{ data: { app: string | null } }>(`${readUrl}/items/OipSubject/${id}`, {
+      headers: { Authorization: `Bearer ${readToken}`, "Cache-Control": "no-store" },
+      query: { fields: "app" },
+    }).catch(() => ({ data: { app: null } }));
+    if (subject.data?.app !== appId) {
+      throw createError({ status: 403, message: "Subject does not belong to this application" });
+    }
+
+    const fields = defined({ ...rest, Keywords: keywords });
+    if (Object.keys(fields).length) await write("PATCH", `/items/OipSubject/${id}`, fields);
+    await upsertTranslations(
+      translations,
+      "OipSubject_translations",
+      "OipSubject_subject_id",
+      id,
+      "subject_name",
+      "subject_description"
+    );
+  }
+
+  return { ok: true };
+});

package/layer/server/api/oip/note-options.get.ts

@@ -0,0 +1,89 @@
+import { defineEventHandler } from "h3";
+import { assertOipSuperAdmin as assertSuperAdmin, oipAppUrls } from "../../utils/oipGuards";
+import type { NoteOptions } from "../../../app/notes/types";
+
+/**
+ * GET /api/oip/note-options, servi par le layer OIP (correction des notes).
+ *
+ * De quoi remplir les listes de l'editeur de notes : categories, ecrans de
+ * l'app, jeux de donnees.
+ *
+ * Une note dit a quoi elle se rapporte par ses sujets (les ecrans du portail)
+ * et par ses sources. Les choisir demande de connaitre les identifiants
+ * Directus, que le navigateur n'a pas : la route les rend deja reduits a un
+ * couple valeur / libelle.
+ *
+ * Deux jetons, parce que deux referentiels : les notes et les sujets se lisent
+ * avec celui des notes, les jeux de donnees avec celui des sources, seul a les
+ * voir. Aucun des deux ne part dans le navigateur.
+ *
+ * Reservee a l'equipe qui redige, comme la correction elle-meme.
+ */
+
+/** L'app du portail dont on veut les ecrans. La meme que /api/notes. */
+
+function pickLabel(rows: any[] | null | undefined, code: string) {
+  const list = rows ?? [];
+  return (list.find((row) => row?.languages_code === code) ?? list[0])?.label ?? "";
+}
+
+export default defineEventHandler(async (event): Promise<NoteOptions> => {
+  await assertSuperAdmin(event);
+
+  const config = useRuntimeConfig();
+  const notesUrl = (config.directusNotesUrl as string | undefined)?.replace(/\/+$/, "");
+  const notesToken = config.directusNotesToken as string | undefined;
+  const sourcesUrl = (config.directusSourcesWriteUrl as string | undefined)?.replace(/\/+$/, "");
+  const sourcesToken = config.directusSourcesWriteToken as string | undefined;
+
+  if (!notesUrl || !notesToken) {
+    throw createError({ status: 503, message: "Notes are not configured" });
+  }
+
+  const notesHeaders = { Authorization: `Bearer ${notesToken}`, "Cache-Control": "no-store" };
+
+  const [categories, subjects, sources] = await Promise.all([
+    $fetch<{ data: any[] }>(`${notesUrl}/items/note_categories`, {
+      headers: notesHeaders,
+      query: {
+        limit: -1,
+        fields: "id,translations.languages_code,translations.label",
+      },
+    }),
+    $fetch<{ data: any[] }>(`${notesUrl}/items/OipSubject`, {
+      headers: notesHeaders,
+      query: {
+        limit: -1,
+        sort: "relative_path",
+        filter: JSON.stringify({ app: { prod_url: { _in: oipAppUrls() } } }),
+        fields: "subject_id,relative_path",
+      },
+    }),
+    // Le referentiel des sources est commun a toutes les apps pays : une note
+    // peut expliquer un jeu que cette app n'affiche pas encore.
+    sourcesUrl && sourcesToken
+      ? $fetch<{ data: any[] }>(`${sourcesUrl}/items/DataSource`, {
+          headers: { Authorization: `Bearer ${sourcesToken}`, "Cache-Control": "no-store" },
+          query: {
+            limit: -1,
+            sort: "Nickname",
+            fields: "source_uuid,Nickname",
+          },
+        })
+      : Promise.resolve({ data: [] as any[] }),
+  ]);
+
+  return {
+    categories: (categories.data ?? []).map((row) => ({
+      id: row.id,
+      fr: pickLabel(row.translations, "fr-FR"),
+      en: pickLabel(row.translations, "en-US"),
+    })),
+    subjects: (subjects.data ?? [])
+      .filter((row) => row?.subject_id && row?.relative_path)
+      .map((row) => ({ id: row.subject_id, path: row.relative_path })),
+    sources: (sources.data ?? [])
+      .filter((row) => row?.source_uuid)
+      .map((row) => ({ uuid: row.source_uuid, label: row.Nickname || row.source_uuid })),
+  };
+});

package/layer/server/api/oip/note.get.ts

@@ -0,0 +1,95 @@
+import { defineEventHandler } from "h3";
+import { z } from "zod";
+import { assertOipSuperAdmin as assertSuperAdmin } from "../../utils/oipGuards";
+import { oipParseNoteContent as parseNoteContent } from "../../utils/oipNoteMarkup";
+import type { AdminNote, AdminNoteTranslation } from "../../../app/notes/types";
+
+/**
+ * GET /api/oip/note, servi par le layer OIP (correction des notes).
+ *
+ * Une note entiere, pour la corriger depuis le rail.
+ *
+ * /api/notes rend ce qu'il faut pour lire : une langue, deja triee, sans les
+ * identifiants Directus. Corriger demande l'inverse — les deux langues cote a
+ * cote, l'id de chaque traduction, les lignes de liaison vers les sujets et
+ * les sources — et ca ne regarde que l'equipe qui redige. D'ou une route a
+ * part, derriere le meme portillon que l'ecriture.
+ *
+ * Le contenu redescend en blocs, pas en texte balise : l'editeur travaille sur
+ * les memes blocs que le panneau, et c'est le serveur qui sait traduire les
+ * deux formes l'une dans l'autre.
+ */
+
+const schema = z.object({ id: z.string().uuid() });
+
+/** Les deux langues que les apps lisent. Le reste du referentiel ne sert pas ici. */
+const LANGUAGES = ["fr-FR", "en-US"] as const;
+
+interface DirectusTranslation {
+  id?: number;
+  languages_code?: string;
+  title?: string | null;
+  summary?: string | null;
+  content?: string | null;
+}
+
+export default defineEventHandler(async (event): Promise<AdminNote> => {
+  await assertSuperAdmin(event);
+
+  const parsed = schema.safeParse(getQuery(event));
+  if (!parsed.success) throw createError({ status: 400, message: "A note id is required" });
+
+  const config = useRuntimeConfig();
+  const url = (config.directusNotesUrl as string | undefined)?.replace(/\/+$/, "");
+  const token = config.directusNotesToken as string | undefined;
+  if (!url || !token) throw createError({ status: 503, message: "Notes are not configured" });
+
+  const response = await $fetch<{ data: any }>(`${url}/items/Notes/${parsed.data.id}`, {
+    headers: { Authorization: `Bearer ${token}`, "Cache-Control": "no-store" },
+    query: {
+      fields: [
+        "id",
+        "status",
+        "category",
+        "translations.id",
+        "translations.languages_code",
+        "translations.title",
+        "translations.summary",
+        "translations.content",
+        "linked_subjects.id",
+        "linked_subjects.OipSubject_subject_id",
+        "linked_sources.id",
+        "linked_sources.DataSource_source_uuid",
+      ].join(","),
+    },
+  });
+
+  const row = response.data;
+  if (!row) throw createError({ status: 404, message: "Note not found" });
+
+  const rows: DirectusTranslation[] = row.translations ?? [];
+
+  return {
+    id: row.id,
+    status: row.status ?? "draft",
+    category: row.category ?? null,
+    // Les deux langues sortent toujours, meme absentes du CMS : l'editeur doit
+    // pouvoir ecrire celle qui manque sans passer par Directus.
+    translations: LANGUAGES.map((code) => {
+      const found = rows.find((item) => item.languages_code === code);
+      return {
+        ...(found?.id ? { id: found.id } : {}),
+        languages_code: code,
+        title: found?.title ?? "",
+        summary: found?.summary ?? "",
+        sections: parseNoteContent(found?.content ?? ""),
+      };
+    }),
+    subjects: (row.linked_subjects ?? [])
+      .filter((link: any) => link?.OipSubject_subject_id)
+      .map((link: any) => ({ linkId: link.id, subjectId: link.OipSubject_subject_id })),
+    sources: (row.linked_sources ?? [])
+      .filter((link: any) => link?.DataSource_source_uuid)
+      .map((link: any) => ({ linkId: link.id, sourceUuid: link.DataSource_source_uuid })),
+  };
+});

package/layer/server/api/oip/notes.get.ts

@@ -0,0 +1,173 @@
+import { defineEventHandler } from "h3";
+import { oipAppUrls } from "../../utils/oipGuards";
+import { oipParseNoteContent as parseNoteContent } from "../../utils/oipNoteMarkup";
+import type { ApiNote } from "../../../app/notes/types";
+
+/**
+ * GET /api/oip/notes, servi par le layer OIP (panneau « Notes »).
+ *
+ * Les notes du rail, lues dans Directus (collection `Notes`).
+ *
+ * Elles etaient ecrites en dur dans `app/notes/*.ts` : une correction de texte
+ * demandait un deploiement. Elles vivent maintenant dans le CMS, ou l'equipe
+ * data les ecrit et les traduit.
+ *
+ * Une note dit a quoi elle se rapporte de deux facons, et il en faut au moins
+ * une : ses `linked_subjects`, les sujets du portail OIP qui portent le chemin
+ * de l'ecran (`relative_path`), et ses `linked_sources`, les jeux Directus
+ * qu'elle explique. Une note attachee a une source sort partout ou cette
+ * source est citee : la note qui dit ce que couvre Medicam suit Medicam, sans
+ * qu'on ait a lister les ecrans qui l'affichent.
+ *
+ * Une note qui ne cite ni sujet ni source ne sort nulle part : un champ vide
+ * veut dire « pas encore rattachee », et le panneau ne peut pas le distinguer
+ * de « vaut pour toute l'app ». Une note transverse se declare, elle ne
+ * s'oublie pas.
+ *
+ * La reponse sort entiere, une fois par langue : 43 notes, c'est moins qu'un
+ * aller-retour par page. Le tri par chemin se fait cote client, qui seul sait
+ * quelle page est ouverte.
+ *
+ * Le navigateur ne voit ni l'URL ni le token Directus.
+ */
+
+const COLLECTION = "Notes";
+
+/** L'app du portail dont on veut les notes. Une autre app, un autre `prod_url`. */
+
+/**
+ * De l'intitule Directus vers la cle de categorie du panneau.
+ *
+ * Directus ne stocke que le libelle traduit ; l'icone et la teinte restent
+ * cote app (cf. `app/notes/categories.ts`), ou elles sont communes aux quatre
+ * sous-apps. Les deux langues sont acceptees : le libelle lu depend de la
+ * langue demandee.
+ */
+const CATEGORY_KEYS: Record<string, string> = {
+  "méthodologie": "method",
+  "methodology": "method",
+  "métriques": "metrics",
+  "metrics": "metrics",
+  "limites": "limits",
+  "limitations": "limits",
+  "conventions": "conventions",
+  "réglementaire": "regulatory",
+  "regulatory": "regulatory",
+  "glossaire": "glossary",
+  "glossary": "glossary",
+  "aide": "help",
+  "help": "help",
+};
+
+interface DirectusTranslation {
+  languages_code?: string;
+  title?: string | null;
+  summary?: string | null;
+  content?: string | null;
+  label?: string | null;
+}
+
+interface DirectusNote {
+  id: string;
+  sort?: number | null;
+  date_created?: string | null;
+  date_updated?: string | null;
+  category?: { translations?: DirectusTranslation[] | null } | null;
+  translations?: DirectusTranslation[] | null;
+  linked_subjects?: {
+    OipSubject_subject_id?: { relative_path?: string | null; app?: { prod_url?: string | null } | null } | null;
+  }[] | null;
+  linked_sources?: { DataSource_source_uuid?: string | null }[] | null;
+}
+
+function pick(rows: DirectusTranslation[] | null | undefined, lang: string) {
+  const list = rows ?? [];
+  const wanted = lang === "en" ? "en-US" : "fr-FR";
+  return (
+    list.find((row) => row.languages_code === wanted) ??
+    list.find((row) => row.languages_code === "fr-FR") ??
+    list[0]
+  );
+}
+
+export default defineEventHandler(async (event): Promise<ApiNote[]> => {
+  const config = useRuntimeConfig();
+  const { lang } = getQuery(event) as { lang?: string };
+  const locale = lang === "en" ? "en" : "fr";
+
+  const appUrls = oipAppUrls();
+  const url = (config.directusNotesUrl as string | undefined)?.replace(/\/+$/, "");
+  const token = config.directusNotesToken as string | undefined;
+
+  if (!url || !token) {
+    throw createError({
+      status: 503,
+      message:
+        "Notes are not configured: set DIRECTUS_URL and DIRECTUS_NOTES_TOKEN " +
+        "(or DIRECTUS_FAVORITES_TOKEN). The token needs read access on the Notes collection.",
+    });
+  }
+
+  const response = await $fetch<{ data: DirectusNote[] }>(`${url}/items/${COLLECTION}`, {
+    // Cette instance Directus garde ses reponses cinq minutes. Une note
+    // corrigee, rattachee ou depubliee doit se voir au rechargement, pas au
+    // quart d'heure suivant.
+    headers: { Authorization: `Bearer ${token}`, "Cache-Control": "no-store" },
+    query: {
+      limit: -1,
+      sort: "sort",
+      filter: JSON.stringify({ status: { _eq: "published" } }),
+      fields: [
+        "id",
+        "sort",
+        "date_created",
+        "date_updated",
+        "category.translations.languages_code",
+        "category.translations.label",
+        "translations.languages_code",
+        "translations.title",
+        "translations.summary",
+        "translations.content",
+        "linked_subjects.OipSubject_subject_id.relative_path",
+        "linked_subjects.OipSubject_subject_id.app.prod_url",
+        "linked_sources.DataSource_source_uuid",
+      ].join(","),
+    },
+  });
+
+  const notes: ApiNote[] = [];
+
+  for (const row of response.data ?? []) {
+    const text = pick(row.translations, locale);
+    const title = (text?.title ?? "").trim();
+    if (!title) continue;
+
+    // Un sujet d'une autre app ne compte pas : la collection est commune a
+    // tout le portail. Sans sujet de cette app, la note n'est pas la sienne.
+    const paths = (row.linked_subjects ?? [])
+      .map((link) => link.OipSubject_subject_id)
+      .filter((subject) => appUrls.includes(subject?.app?.prod_url))
+      .map((subject) => (subject!.relative_path ?? "").trim())
+      .filter(Boolean);
+    const sources = (row.linked_sources ?? [])
+      .map((link) => (link.DataSource_source_uuid ?? "").trim())
+      .filter(Boolean);
+
+    if (paths.length === 0 && sources.length === 0) continue;
+
+    const label = (pick(row.category?.translations, locale)?.label ?? "").trim();
+
+    notes.push({
+      id: row.id,
+      category: CATEGORY_KEYS[label.toLowerCase()] ?? "help",
+      updated: (row.date_updated || row.date_created || "").slice(0, 10),
+      title,
+      summary: (text?.summary ?? "").trim(),
+      sections: parseNoteContent(text?.content ?? ""),
+      paths,
+      sources,
+    });
+  }
+
+  return notes;
+});