@tekkare/romulus 0.1.240 → 0.1.242

package/layer/app/types/oip.ts

@@ -0,0 +1,60 @@
+// Formes partagees par le cadre OIP 7 du layer. RmSidebarLeft (Romulus) ne
+// publie pas ses types : on redecrit ici le strict necessaire.
+
+export type OipNavItem = {
+  label: string;
+  icon?: string;
+  to?: string;
+  href?: string;
+  badge?: string;
+  active?: boolean;
+};
+
+export type OipNavSection = {
+  key: string;
+  label?: string;
+  items: OipNavItem[];
+  collapsible?: boolean;
+};
+
+/**
+ * Une tuile du rail, telle que le layout la declare : une largeur de panneau
+ * quand la tuile en demande une autre que la largeur commune, un `count` pour
+ * une pastille de comptage, `dot` + `hint` pour un etat actif a signaler.
+ */
+export type OipRailTile = {
+  key: string;
+  label: string;
+  icon: string;
+  width?: string;
+  count?: number;
+  dot?: boolean;
+  hint?: string;
+  disabled?: boolean;
+};
+
+/** Un maillon du fil d'Ariane qui quitte l'app (href) : plateforme, pays. */
+export type OipExternalCrumb = {
+  label: string;
+  href: string;
+  /** Code ISO alpha-2 dessine devant le libelle (cf. RmFlag). */
+  flag?: string;
+};
+
+/**
+ * Une partie d'un hub (fr_drugs : Medicaments, Hub-R...). Le fil d'Ariane
+ * nomme la partie courante et propose les autres au clic.
+ */
+export type OipPart = {
+  key: string;
+  label: string;
+  /** Absent : le libelle francais sert dans les deux langues. */
+  labelEn?: string;
+  /** Route d'accueil, non prefixee de la locale. */
+  to: string;
+  icon?: string;
+  /** Tenue hors du menu du fil, mais nommee quand on est dedans. */
+  hidden?: boolean;
+};
+
+export type OipLocaleOption = { code: string; flag: string; label: string };

package/layer/app/types/tableGroups.ts

@@ -0,0 +1,42 @@
+/**
+ * Les tablegroups Directus d'un sujet (un ecran), pour l'onglet « Tables » du
+ * panneau Sources. Un tablegroup regroupe des tables Redshift (`Dataset`).
+ */
+export interface TableGroupDataset {
+  schema_name: string;
+  table_name: string;
+  nickname: string;
+  short_description: string;
+  last_update: string | null;
+  update_frequency: string;
+  start_period: string | null;
+  end_period: string | null;
+  location: string;
+  geographical_scope: string;
+  geographical_granularity: string;
+}
+
+/** Le lien d'un tablegroup vers un data package, et ce qu'il y apporte. */
+export interface TableGroupPackage {
+  id: string;
+  /** Vide tant que le jeton ne lit pas `DataPackage`. */
+  name: string;
+  tags: string[];
+  summary: string;
+}
+
+export interface TableGroup {
+  id: string;
+  title: string;
+  short_description: string;
+  category: string;
+  status: string;
+  date_updated: string | null;
+  packages: TableGroupPackage[];
+  datasets: TableGroupDataset[];
+}
+
+export interface SubjectTableGroups {
+  relative_path: string;
+  groups: TableGroup[];
+}

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/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;
+  }
+});

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

@@ -0,0 +1,109 @@
+import { defineEventHandler } from "h3";
+import { assertOipSuperAdmin, oipAppUrls } from "../../utils/oipGuards";
+import type { Metadata, MetadataTranslation } from "../../../app/types/metadata";
+
+/**
+ * GET /api/oip/metadata, servi par le layer OIP (panneau « Métadonnées »).
+ *
+ * Les metadonnees Directus de cette app : sa fiche `OipApplication` et ses
+ * `OipSubject`, pour le panneau « Métadonnées » du rail.
+ *
+ * L'app est designee par son `prod_url`, comme pour les notes : la
+ * collection est commune a tout le portail, et un sujet d'une autre app ne
+ * regarde pas celle-ci.
+ *
+ * Reservee aux superadmins, comme la correction : c'est un outil de relecture
+ * du referentiel, pas une information de lecture.
+ */
+
+function translations(rows: any[] | null | undefined, name: string, description: string): MetadataTranslation[] {
+  return (rows ?? []).map((row) => ({
+    id: row.id,
+    languages_code: String(row.languages_code || "").trim(),
+    name: row[name] ?? "",
+    description: row[description] ?? "",
+  }));
+}
+
+export default defineEventHandler(async (event): Promise<Metadata> => {
+  await assertOipSuperAdmin(event);
+  const appUrls = oipAppUrls();
+
+  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: "Metadata is not configured" });
+  }
+
+  const headers = { Authorization: `Bearer ${token}`, "Cache-Control": "no-store" };
+
+  const [apps, subjects] = await Promise.all([
+    $fetch<{ data: any[] }>(`${url}/items/OipApplication`, {
+      headers,
+      query: {
+        limit: 1,
+        filter: JSON.stringify({ prod_url: { _eq: appUrls[0] } }),
+        fields: [
+          "app_id",
+          "status",
+          "prod_url",
+          "staging_url",
+          "github_front_url",
+          "categories",
+          "date_updated",
+          "translations.id",
+          "translations.languages_code",
+          "translations.application_name",
+          "translations.application_description",
+        ].join(","),
+      },
+    }),
+    $fetch<{ data: any[] }>(`${url}/items/OipSubject`, {
+      headers,
+      query: {
+        limit: -1,
+        sort: "relative_path",
+        filter: JSON.stringify({ app: { prod_url: { _in: appUrls } } }),
+        fields: [
+          "subject_id",
+          "status",
+          "relative_path",
+          "Keywords",
+          "is_specialized_report",
+          "date_updated",
+          "translations.id",
+          "translations.languages_code",
+          "translations.subject_name",
+          "translations.subject_description",
+        ].join(","),
+      },
+    }),
+  ]);
+
+  const app = apps.data?.[0];
+
+  return {
+    application: app
+      ? {
+          id: app.app_id,
+          status: app.status ?? "",
+          prod_url: app.prod_url ?? "",
+          staging_url: app.staging_url ?? "",
+          github_front_url: app.github_front_url ?? "",
+          categories: Array.isArray(app.categories) ? app.categories : [],
+          date_updated: app.date_updated ?? null,
+          translations: translations(app.translations, "application_name", "application_description"),
+        }
+      : null,
+    subjects: (subjects.data ?? []).map((row) => ({
+      id: row.subject_id,
+      status: row.status ?? "",
+      relative_path: row.relative_path ?? "",
+      keywords: row.Keywords ?? "",
+      is_specialized_report: !!row.is_specialized_report,
+      date_updated: row.date_updated ?? null,
+      translations: translations(row.translations, "subject_name", "subject_description"),
+    })),
+  };
+});