@tekkare/romulus 0.1.241 → 0.1.243

package/layer/app/utils/oipRail.ts

@@ -0,0 +1,82 @@
+// Catalogue du rail droit OIP 7 : l'ordre, le nom, l'icone et le regroupement
+// de chaque tuile. Fixe pour toutes les apps : le lecteur retrouve chaque
+// outil a la meme place d'un ecran et d'une app a l'autre. Une app ne declare
+// que l'etat des tuiles (servie ou non, pastille, point), cf. OipShell `tiles`.
+
+export type OipRailTileKey =
+  | "Sources"
+  | "SourcesTables"
+  | "Notes"
+  | "Documents"
+  | "Views"
+  | "Alerts"
+  | "AdminTemplates"
+  | "Export"
+  | "Projects"
+  | "Topics"
+  | "Tutorials"
+  | "Accessibility"
+  | "Metadata";
+
+export type OipRailGroupKey = "Documentation" | "ViewsAlerts";
+
+export type OipRailEntry = {
+  key: OipRailTileKey;
+  label: { fr: string; en: string };
+  icon: string;
+  /** Lue en onglet d'un panneau commun avec les autres membres du groupe. */
+  group?: OipRailGroupKey;
+  /** Reservee aux superadmins. */
+  admin?: boolean;
+  /** Toujours servie, quel que soit l'ecran : elle ne depend pas de la page. */
+  frame?: boolean;
+  /** Sa pastille reste sur son onglet, sans s'ajouter a celle du groupe. */
+  ownCount?: boolean;
+};
+
+export const OIP_RAIL_GROUPS: Record<OipRailGroupKey, { label: { fr: string; en: string }; icon?: string }> = {
+  Documentation: { label: { fr: "À propos de l'app", en: "About the app" }, icon: "info" },
+  ViewsAlerts: { label: { fr: "Vues et alertes", en: "Views and alerts" } },
+};
+
+export const OIP_RAIL_TILES: OipRailEntry[] = [
+  { key: "Sources", label: { fr: "Sources", en: "Sources" }, icon: "database", group: "Documentation" },
+  // Seconde vue du panneau Sources : les tablegroups Directus de l'ecran.
+  {
+    key: "SourcesTables",
+    label: { fr: "Tables", en: "Tables" },
+    icon: "table",
+    group: "Documentation",
+    ownCount: true,
+  },
+  { key: "Notes", label: { fr: "Notes", en: "Notes" }, icon: "notepad", group: "Documentation" },
+  { key: "Documents", label: { fr: "Documents", en: "Documents" }, icon: "file-text", group: "Documentation" },
+  { key: "Views", label: { fr: "Mes vues", en: "My views" }, icon: "bookmark-simple", group: "ViewsAlerts" },
+  { key: "Alerts", label: { fr: "Alertes", en: "Alerts" }, icon: "bell", group: "ViewsAlerts" },
+  {
+    key: "AdminTemplates",
+    label: { fr: "Admin templates", en: "Admin templates" },
+    icon: "magic-wand",
+    group: "ViewsAlerts",
+    admin: true,
+  },
+  { key: "Export", label: { fr: "Export", en: "Export" }, icon: "export" },
+  { key: "Projects", label: { fr: "Projets", en: "Projects" }, icon: "folder-simple" },
+  { key: "Topics", label: { fr: "Mes sujets", en: "My topics" }, icon: "star" },
+  { key: "Tutorials", label: { fr: "Tutoriels", en: "Tutorials" }, icon: "graduation-cap", frame: true },
+  { key: "Accessibility", label: { fr: "Accessibilité", en: "Accessibility" }, icon: "person-arms-spread", frame: true },
+  { key: "Metadata", label: { fr: "Métadonnées", en: "Metadata" }, icon: "brackets-curly", admin: true, frame: true },
+];
+
+/** Etat d'une tuile pour l'ecran : `true` la sert, un objet la sert avec sa pastille. */
+export type OipRailTileState =
+  | boolean
+  | {
+      count?: number;
+      /** Point d'etat actif (une vue appliquee), avec son infobulle. */
+      dot?: boolean;
+      hint?: string;
+      disabled?: boolean;
+    };
+
+export type OipRailTileStates = Partial<Record<OipRailTileKey, OipRailTileState>>;

package/layer/app/utils/postLoginRedirect.ts

@@ -0,0 +1,58 @@
+/**
+ * Post-login redirect handling.
+ *
+ * When an unauthenticated user hits a protected deep link, the auth middleware
+ * bounces them to `/?redirect=<path>`. That query param is enough for in-SPA
+ * login flows, but it is lost as soon as we leave the app (OAuth round-trip
+ * through FusionAuth, magic-link email opened later). We therefore also persist
+ * the intended destination in sessionStorage so it survives a full reload.
+ */
+
+const STORAGE_KEY = "postLoginRedirect";
+
+/**
+ * Only accept in-app relative paths to avoid open-redirect attacks.
+ * Must start with a single "/" (not "//" or "/\" which browsers treat as
+ * protocol-relative external URLs).
+ */
+function isSafeRedirectPath(target: unknown): target is string {
+  return (
+    typeof target === "string" &&
+    target.startsWith("/") &&
+    !target.startsWith("//") &&
+    !target.startsWith("/\\")
+  );
+}
+
+/** Persist the intended destination (no-op if invalid). */
+export function savePostLoginRedirect(target: unknown): void {
+  if (import.meta.client && isSafeRedirectPath(target)) {
+    sessionStorage.setItem(STORAGE_KEY, target);
+  }
+}
+
+/**
+ * Resolve the best post-login destination without mutating storage: query
+ * param first (most explicit), then persisted storage, then "/".
+ */
+export function getPostLoginRedirect(queryRedirect?: unknown): string {
+  if (isSafeRedirectPath(queryRedirect)) {
+    return queryRedirect;
+  }
+  if (import.meta.client) {
+    const stored = sessionStorage.getItem(STORAGE_KEY);
+    if (isSafeRedirectPath(stored)) {
+      return stored;
+    }
+  }
+  return "/";
+}
+
+/** Same as getPostLoginRedirect but clears storage so it is used only once. */
+export function takePostLoginRedirect(queryRedirect?: unknown): string {
+  const target = getPostLoginRedirect(queryRedirect);
+  if (import.meta.client) {
+    sessionStorage.removeItem(STORAGE_KEY);
+  }
+  return target;
+}

package/layer/app/utils/valueTable.ts

@@ -0,0 +1,126 @@
+/**
+ * valueTable - un tableau Auriga rendu par RmTable.
+ *
+ * Les analyses du portail construisent leurs tableaux comme `arg-table` les
+ * attendait : une liste de libelles de tete, et des lignes `{ values: [...] }`
+ * dans le meme ordre. RmTable, lui, lit des colonnes nommees et des lignes
+ * indexees par ces noms. La conversion est mecanique : elle vit ici plutot que
+ * recopiee dans chaque composant, et le calcul des valeurs reste ou il est.
+ *
+ * Les colonnes portent des cles positionnelles (`c0`, `c1`...) : les libelles
+ * de tete sont traduits et ne font pas des cles stables. `valueKeys` donne les
+ * colonnes de valeurs, celles dont le composant rend le contenu par un slot.
+ *
+ * `types` reprend `column-type` d'`arg-table`, `style` reprend `columnStyle`.
+ */
+export interface ValueTableRow {
+  values: any[];
+}
+
+export interface ValueTableStyle {
+  /** Parts de largeur, comme `columnStyle.size` d'`arg-table`. */
+  size?: readonly number[];
+  /** Alignements imposes, comme `columnStyle.align`. Priment sur `types`. */
+  align?: readonly ("left" | "right" | "center")[];
+  /**
+   * Largeur plancher par colonne (CSS). A la difference de `size`, qui repartit
+   * la place restante, elle ne se rogne pas : la table defile plutot que
+   * d'ecraser une colonne de libelles longs.
+   */
+  minWidth?: readonly (string | undefined)[];
+}
+
+export function valueTable(
+  heads: any[],
+  contents: any[],
+  types?: any[],
+  style?: ValueTableStyle,
+) {
+  // Sans types, la premiere colonne porte le libelle et les suivantes des
+  // valeurs. Certains tableaux en ont deux (le nom puis le code) : leurs types
+  // de colonnes le disent deja, une colonne sans type ne porte pas un nombre.
+  // `url` est la colonne d'action d'`arg-table` : un bouton se centre.
+  const alignOf = (index: number): "left" | "right" | "center" => {
+    if (style?.align?.[index]) return style.align[index];
+    if (!types) return index === 0 ? "left" : "right";
+    if (!types[index]) return "left";
+    return types[index] === "url" ? "center" : "right";
+  };
+
+  // `arg-table` reglait la largeur des colonnes par des parts (`size: [1, 4, 1]`)
+  // : la colonne a 4 prend quatre fois la place de celle a 1. RmTable prend une
+  // largeur CSS, on rend donc la part en pourcentage du total.
+  const sizes = style?.size;
+  const total = sizes ? sizes.reduce((sum, part) => sum + part, 0) : 0;
+  const widthOf = (index: number) =>
+    sizes && total && sizes[index]
+      ? `${Math.round((sizes[index] * 1000) / total) / 10}%`
+      : undefined;
+
+  const allColumns = heads.map((label: any, index: number) => ({
+    key: `c${index}`,
+    label: String(label),
+    sortable: true,
+    align: alignOf(index),
+    width: widthOf(index),
+    minWidth: style?.minWidth?.[index],
+  }));
+
+  // La colonne de type `More` d'`arg-table` ne portait pas une valeur a lire :
+  // elle tenait le chevron de depliage et la charge utile du detail. RmTable
+  // pose son propre chevron (`expandable`) dans une colonne a lui, celle-ci
+  // sort donc de la tete ; la charge reste dans la ligne, sous sa cle, ou le
+  // slot `expanded` va la chercher.
+  const moreIndex = (types ?? []).findIndex((type: any) => type === "More");
+  // Cle vide plutot que `null` quand la table n'a pas de colonne `More` : les
+  // pages lisent `row[table.moreKey]` dans leurs slots, et une cle nullable ne
+  // s'indexe pas. Une cle vide ne designe aucune colonne, ce que `null`
+  // disait deja.
+  const moreKey = moreIndex >= 0 ? `c${moreIndex}` : "";
+  const columns = allColumns.filter((column) => column.key !== moreKey);
+
+  const rows = (Array.isArray(contents) ? contents : [])
+    .filter((row: any) => Array.isArray(row?.values))
+    .map((row: ValueTableRow) =>
+      Object.fromEntries(row.values.map((value, index) => [`c${index}`, value])),
+    );
+
+  // `arg-table` nommait ses slots de cellule par le type de colonne
+  // (`#Date`, `#Price`), plusieurs colonnes pouvant partager un type. RmTable
+  // nomme les siens par la cle de colonne : `typeKeys` dit quelles cles porte
+  // un type, pour que la page rende le slot une fois par cle.
+  const typeKeys: Record<string, string[]> = {};
+  (types ?? []).forEach((type: any, index: number) => {
+    if (!type || type === "More" || !allColumns[index]) return;
+    (typeKeys[type] ??= []).push(allColumns[index]!.key);
+  });
+
+  return {
+    columns,
+    rows,
+    typeKeys,
+    /** Vrai quand la table avait une colonne `More` : passer `expandable` a RmTable. */
+    expandable: moreIndex >= 0,
+    /** Cle ou vit la charge utile du detail, a lire dans le slot `expanded`. Vide sans colonne `More`. */
+    moreKey,
+    valueKeys: columns.slice(1).map((column) => column.key),
+  };
+}
+
+/**
+ * Les cles de colonne qui portent un type donne, quand la table a ete
+ * construite sans ses `types` : `columnKeysOfType(tableTypes, "int")` rend
+ * `["c2", "c3"]`, de quoi rendre le slot de cellule une fois par colonne.
+ *
+ * C'est le pendant de `typeKeys` ci-dessus pour les tableaux qui gardent
+ * leurs types a part, parce que les passer a `valueTable` changerait aussi
+ * l'alignement des colonnes. Vingt et un composants le recopiaient, sous
+ * trois ecritures differentes.
+ */
+export const columnKeysOfType = (
+  types: readonly any[] | undefined,
+  wanted: string,
+): string[] =>
+  (types ?? [])
+    .map((type, index) => (type === wanted ? `c${index}` : null))
+    .filter((key): key is string => key !== null);

package/layer/nuxt.config.ts

@@ -0,0 +1,32 @@
+// Layer Nuxt livre avec @tekkare/romulus : une app l'active avec
+// `extends: ['@tekkare/romulus/layer']`.
+// Ses dossiers app/ et server/ fusionnent avec ceux de l'app, qui garde la
+// priorite sur tout fichier de meme nom (c'est la porte de sortie pour
+// surcharger un composant, un layout ou une route).
+//
+// Le layer s'appuie sur le module Romulus et @nuxtjs/i18n mais ne les declare
+// pas dans `modules` : l'app les enregistre deja avec ses options (romulus
+// sans baseStyles, ses locales), et un second enregistrement par le layer
+// les reinstallerait avec les options par defaut.
+export default defineNuxtConfig({
+  future: {
+    compatibilityVersion: 4,
+  },
+  // Reglages serveur propres au layer. Les cles Directus (directus*Url,
+  // directus*Token) restent declarees par l'app, qui les avait deja.
+  runtimeConfig: {
+    /** Nom du cookie de session, sinon le premier `*.session-token`. */
+    oipSessionCookie: "",
+    /** Element OipTutorials de la video de prise en main. Vide : pas de video. */
+    oipTutorialVideoId: "",
+    /** `prod_url` de l'app dans le portail (fiche OipApplication), sinon NOTES_APP_URL. */
+    oipAppUrl: "",
+    /** API Virtual Lab pour le droit superadmin, sinon VIRTUAL_LAB_API_URL. */
+    oipVirtualLabApiUrl: "",
+    /** Directus qui porte la collection ElasticIndices, et un jeton qui la lit. */
+    oipEsIndicesUrl: "",
+    oipEsIndicesToken: "",
+    /** Vrai en preproduction : interroge `staging_physical` quand il existe. */
+    oipEsIndicesStaging: false,
+  },
+});

package/layer/server/api/oip/asset/[id].get.ts

@@ -0,0 +1,89 @@
+import { defineEventHandler } from "h3";
+import { requireOipSession } from "../../../utils/oipAuth";
+
+/**
+ * GET /api/oip/asset/<id>, servi par le layer OIP.
+ *
+ * Sert un fichier Directus (les documents du panneau Documents).
+ *
+ * Passe par le serveur plutot qu'un lien direct pour que l'hote Directus ne
+ * parte jamais dans le navigateur. Le header Range est relaye — c'est lui qui
+ * permet d'ouvrir un PDF page par page — et `?download` demande a Directus une
+ * disposition de piece jointe.
+ */
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+const PASS_THROUGH = [
+  "content-type",
+  "content-length",
+  "content-range",
+  "content-disposition",
+  "accept-ranges",
+  "etag",
+  "last-modified",
+];
+
+/**
+ * Types que le navigateur peut afficher en place. Tout autre type (HTML, SVG,
+ * texte...) part en piece jointe : servi sur l'origine de l'app, un document
+ * HTML s'executerait avec ses cookies.
+ */
+const INLINE_TYPES = new Set([
+  "application/pdf",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "text/csv",
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+]);
+
+export default defineEventHandler(async (event) => {
+  // Documents reserves aux personnes connectees, comme le dit le cache-control.
+  await requireOipSession(event);
+
+  const config = useRuntimeConfig();
+  const base = (config.directusDocumentsUrl as string | undefined)?.replace(/\/+$/, "");
+  const id = getRouterParam(event, "id") ?? "";
+
+  if (!base) {
+    throw createError({ status: 503, message: "Directus is not configured: set DIRECTUS_URL" });
+  }
+  if (!UUID.test(id)) {
+    throw createError({ status: 400, message: "Invalid asset id" });
+  }
+
+  const { download } = getQuery(event);
+  const range = getHeader(event, "range");
+
+  const upstream = await fetch(
+    `${base}/assets/${id}${download === undefined ? "" : "?download"}`,
+    { headers: range ? { range } : {} }
+  );
+
+  if (!upstream.ok && upstream.status !== 206) {
+    throw createError({ status: upstream.status, message: "Asset unavailable" });
+  }
+
+  setResponseStatus(event, upstream.status);
+  // Pas le `cache-control` de Directus (public, 30 jours) : ces documents ne
+  // sont servis qu'aux personnes connectees, une reponse gardee un mois par
+  // les caches partages n'a rien a faire la. Une heure suffit a eviter de
+  // retelecharger un PDF qu'on rouvre, et un en-tete de securite corrige
+  // arrive au navigateur dans la journee au lieu du mois prochain.
+  setResponseHeader(event, "cache-control", "private, max-age=3600");
+  for (const header of PASS_THROUGH) {
+    const value = upstream.headers.get(header);
+    if (value) setResponseHeader(event, header, value);
+  }
+
+  const type = (upstream.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (!INLINE_TYPES.has(type)) {
+    // Le nom de fichier de Directus est garde, seule la disposition change.
+    const disposition = upstream.headers.get("content-disposition") || "attachment";
+    setResponseHeader(event, "content-disposition", disposition.replace(/^inline/i, "attachment"));
+  }
+
+  return upstream.body;
+});

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

@@ -0,0 +1,92 @@
+import { defineEventHandler } from "h3";
+
+/**
+ * GET /api/oip/documents, servi par le layer OIP (panneau « Documents »).
+ *
+ * Documents de reference du portail OIP 7 (collection Directus oipDocuments),
+ * restreints a ceux qui parlent des donnees de l'app.
+ *
+ * La selection est explicite, ligne a ligne, et propre a chaque app : elle
+ * vit dans app.config.oip.panels.Documents.catalog (id Directus, categorie,
+ * parties de l'app concernees). Un document sans `apps` vaut pour toutes.
+ * `?app=` filtre la liste ; sans lui elle sort entiere (accueil d'un hub).
+ *
+ * Le navigateur ne voit ni l'URL ni le token Directus : les fichiers passent
+ * par /api/oip/asset/<id>.
+ */
+
+const COLLECTION = "oipDocuments";
+
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  // La partie du hub qui demande. Inconnue ou absente : toute la liste, comme
+  // sur l'accueil, qui n'est aucune des cinq.
+  const { app } = getQuery(event) as { app?: string };
+  const catalog = useAppConfig().oip.panels.Documents.catalog as {
+    id: number;
+    category: string;
+    apps?: string[];
+  }[];
+  const wanted = catalog.filter((doc) => !app || !doc.apps?.length || doc.apps.includes(app));
+  if (!wanted.length) return [];
+  const url = (config.directusDocumentsUrl as string | undefined)?.replace(/\/+$/, "");
+  const token = config.directusDocumentsToken as string | undefined;
+
+  if (!url || !token) {
+    throw createError({
+      status: 503,
+      message:
+        "Documents are not configured: set DIRECTUS_URL and DIRECTUS_DOCUMENTS_TOKEN " +
+        "(or DIRECTUS_FAVORITES_TOKEN). The token needs read access on oipDocuments.",
+    });
+  }
+
+  const response = await $fetch<{ data: any[] }>(`${url}/items/${COLLECTION}`, {
+    headers: { Authorization: `Bearer ${token}` },
+    query: {
+      limit: -1,
+      filter: JSON.stringify({ id: { _in: wanted.map((doc) => doc.id) } }),
+      fields: ["id", "title", "document"].join(","),
+    },
+  });
+
+  const rows = new Map<number, any>((response.data ?? []).map((row) => [Number(row.id), row]));
+
+  // L'ordre vient de la selection, pas de Directus : c'est le seul endroit ou
+  // il est decide, et un document retire du CMS disparait sans trou.
+  const selected = wanted.flatMap(({ id, category }) => {
+    const row = rows.get(id);
+    if (!row?.document) return [];
+    return [
+      {
+        id,
+        category,
+        title: row.title ?? "",
+        fileId: row.document as string,
+        src: `/api/oip/asset/${row.document}`,
+        downloadSrc: `/api/oip/asset/${row.document}?download`,
+      },
+    ];
+  });
+
+  // Le type du fichier decide de ce que le panneau propose : un PDF s'ouvre en
+  // apercu dans l'app, un tableur non. Directus refuse /files a ce token, il
+  // vient donc des entetes de l'asset lui-meme.
+  return Promise.all(
+    selected.map(async ({ fileId, ...doc }) => ({
+      ...doc,
+      mime: await assetMime(`${url}/assets/${fileId}`),
+    })),
+  );
+});
+
+/** Type d'un asset, lu dans ses entetes. Jamais fatal : un document dont le
+ *  type est inconnu se liste et se telecharge quand meme. */
+async function assetMime(url: string): Promise<string | null> {
+  try {
+    const head = await fetch(url, { method: "HEAD" });
+    return head.headers.get("content-type");
+  } catch {
+    return null;
+  }
+}

package/layer/server/api/oip/es-indices.get.ts

@@ -0,0 +1,21 @@
+import { defineEventHandler } from "h3";
+import { requireOipSession } from "../../utils/oipAuth";
+import { oipEsIndexRegistry } from "../../utils/oipEsIndices";
+
+/**
+ * GET /api/oip/es-indices, servi par le layer OIP.
+ *
+ * L'id Directus, le nom canonique et l'index physique de chaque index, pour les rares endroits
+ * du navigateur qui doivent transmettre un NOM a un autre systeme (moteur
+ * d'alertes, registre des types de ressources). Les requetes, elles, passent
+ * l'id au proxy, qui resout lui-meme.
+ */
+export default defineEventHandler(async (event) => {
+  await requireOipSession(event);
+  const { byId } = await oipEsIndexRegistry();
+  return [...byId.values()].map((row) => ({
+    id: row.id,
+    name: row.canonical_name,
+    physical: row.physical_index,
+  }));
+});

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

@@ -0,0 +1,107 @@
+import { defineEventHandler } from "h3";
+import { requireOipUserId } from "../../utils/oipAuth";
+
+/**
+ * GET /api/oip/favorites, servi par le layer OIP (panneau « Mes sujets »).
+ *
+ * The caller's starred topics, as set from the OIP platform menus.
+ *
+ * Read-only on purpose: the star lives in the platform, this app only lists
+ * what it holds so the reader can come back to a topic. Rows are resolved
+ * here (translations, icon, country, target URL) so the browser needs nothing
+ * from Directus, and never sees its URL or token.
+ *
+ * A favourite points at exactly one of two things: a menu item (a catalogue
+ * entry) or a subject (a page, with its application and path).
+ */
+
+/** Directus renders "Oip Favorites" for this raw name. Overridable so a rename in the CMS is an env change. */
+const COLLECTION = process.env.DIRECTUS_FAVORITES_COLLECTION || "Oip_Favorites";
+
+const FIELDS = {
+  user: "user_id",
+  menuItem: "Menu_item",
+  subject: "Subject",
+} as const;
+
+export default defineEventHandler(async (event) => {
+  const userId = await requireOipUserId(event);
+  const config = useRuntimeConfig();
+  const url = (config.directusFavoritesUrl as string | undefined)?.replace(/\/+$/, "");
+  const token = config.directusFavoritesToken as string | undefined;
+
+  if (!url || !token) {
+    throw createError({
+      status: 503,
+      message:
+        "Favourites are not configured: set DIRECTUS_URL and DIRECTUS_FAVORITES_TOKEN. " +
+        "The token needs read access on the Oip_Favorites collection.",
+    });
+  }
+
+  const F = FIELDS;
+  try {
+    const response = await $fetch<{ data: any[] }>(`${url}/items/${COLLECTION}`, {
+      headers: { Authorization: `Bearer ${token}`, "Cache-Control": "no-store" },
+      query: {
+        limit: 200,
+        // A star lit a moment ago in the platform must show up here. This
+        // Directus instance keeps its own five-minute cache keyed on the
+        // normalised query, so the extra clause carries the current instant
+        // and gives every read its own key. It excludes nothing: the bound is
+        // a day ahead, which no row reaches.
+        filter: JSON.stringify({
+          _and: [
+            { [F.user]: { _eq: userId } },
+            { date_created: { _lte: new Date(Date.now() + 86400000).toISOString() } },
+          ],
+        }),
+        sort: "-date_created",
+        fields: [
+          "id",
+          `${F.menuItem}.id`,
+          `${F.menuItem}.Label`,
+          `${F.menuItem}.Emoji`,
+          `${F.menuItem}.translations.*`,
+          `${F.menuItem}.Country.country_label`,
+          // Le code ISO-2 sert a poser le drapeau : Directus ne stocke pas
+          // d'emoji de pays.
+          `${F.menuItem}.Country.country_iso`,
+          // A menu item is a catalogue entry with no address of its own. Its
+          // subjects come along so a row can open the one behind it instead of
+          // dropping the reader on the platform hub.
+          `${F.menuItem}.Subjects.OipSubject_subject_id.subject_id`,
+          `${F.menuItem}.Subjects.OipSubject_subject_id.relative_path`,
+          `${F.menuItem}.Subjects.OipSubject_subject_id.app.prod_url`,
+          `${F.subject}.subject_id`,
+          `${F.subject}.relative_path`,
+          `${F.subject}.app.prod_url`,
+          `${F.subject}.translations.*`,
+          `${F.subject}.country_iso.country_label`,
+          `${F.subject}.country_iso.country_iso`,
+        ].join(","),
+      },
+    });
+
+    // Normalised on the way out: the CMS spelling of the columns stays here,
+    // the interface always sees `menu_item` and `subject`.
+    return (response.data ?? []).map((row: any) => ({
+      id: row.id,
+      menu_item: row[F.menuItem] ?? null,
+      subject: row[F.subject] ?? null,
+    }));
+  } catch (error: any) {
+    // Directus answers 403 both for "no permission" and for "no such
+    // collection", on purpose. Saying so plainly beats a bare 403.
+    const status = error?.response?.status ?? error?.statusCode;
+    if (status === 403 || status === 404) {
+      throw createError({
+        status: 503,
+        message:
+          `Directus collection "${COLLECTION}" is unreachable: the token in ` +
+          "DIRECTUS_FAVORITES_TOKEN has no read access on it.",
+      });
+    }
+    throw error;
+  }
+});