@tekkare/romulus 0.1.241 → 0.1.242

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

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { defineEventHandler } from "h3";
+import {
+  assertOipSuperAdmin as assertSuperAdmin,
+  oipCheckRateLimit as checkRateLimit,
+  oipClientIp as getClientIp,
+  oipValidateBody as validateBody,
+} from "../../utils/oipGuards";
+import { oipSerializeNoteContent as serializeNoteContent } from "../../utils/oipNoteMarkup";
+import type { NoteSection } from "../../../app/notes/types";
+
+/**
+ * PATCH /api/oip/notes, servi par le layer OIP (correction des notes).
+ *
+ * Correction d'une note depuis le panneau « Notes » du rail.
+ *
+ * Meme forme que la correction des sources : 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.
+ *
+ * Quatre ecritures possibles, toutes facultatives : la fiche (categorie,
+ * statut), ses traductions, ses sujets, ses sources. Un champ absent du corps
+ * n'est pas efface ; une liste de rattachements presente, en revanche, fait
+ * foi : c'est ce que l'editeur a sous les yeux, y compris vide.
+ *
+ * Les rattachements sont compares a ce que Directus porte, pas a ce que le
+ * navigateur affirme : les lignes a defaire sont relues ici, sinon un client
+ * pourrait faire supprimer la liaison d'une autre note en envoyant son id.
+ *
+ * Le contenu arrive en blocs et repart en texte balise : le CMS garde un texte
+ * relisible dans son propre editeur, et une note corrigee depuis l'app se
+ * relit a l'identique (cf. server/utils/note-markup).
+ */
+
+const LANGUAGES = ["fr-FR", "en-US"] as const;
+
+const block: z.ZodType<any> = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("text"), text: z.string().max(4000) }),
+  z.object({ type: z.literal("list"), items: z.array(z.string().max(2000)).max(50) }),
+  z.object({
+    type: z.literal("terms"),
+    items: z
+      .array(z.object({ term: z.string().max(200), def: z.string().max(2000).optional() }))
+      .max(50),
+  }),
+  z.object({
+    type: z.literal("callout"),
+    text: z.string().max(4000),
+    tone: z.enum(["info", "warning"]).optional(),
+  }),
+  z.object({ type: z.literal("example"), text: z.string().max(4000) }),
+  z.object({ type: z.literal("link"), to: z.string().max(300), label: z.string().max(200) }),
+]);
+
+const schema = z.object({
+  id: z.string().uuid(),
+  status: z.enum(["published", "draft", "archived"]).optional(),
+  category: z.string().uuid().nullable().optional(),
+  translations: z
+    .array(
+      z.object({
+        id: z.number().int().positive().optional(),
+        languages_code: z.enum(LANGUAGES),
+        title: z.string().max(300).optional(),
+        summary: z.string().max(2000).optional(),
+        sections: z
+          .array(z.object({ title: z.string().max(200).optional(), blocks: z.array(block).max(80) }))
+          .max(40)
+          .optional(),
+      })
+    )
+    .max(LANGUAGES.length)
+    .optional(),
+  /** Liste complete des ecrans rattaches. Presente, elle fait foi. */
+  subjects: z.array(z.string().uuid()).max(100).optional(),
+  /** Liste complete des jeux de donnees rattaches. Presente, elle fait foi. */
+  sources: z.array(z.string().uuid()).max(100).optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  checkRateLimit(`notes-write:${getClientIp(event)}`, 30, 15 * 60 * 1000);
+
+  await assertSuperAdmin(event);
+
+  const body = await validateBody(event, schema);
+  const config = useRuntimeConfig();
+
+  const base = (config.directusSourcesWriteUrl as string | undefined)?.replace(/\/$/, "");
+  const token = config.directusSourcesWriteToken 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" | "DELETE",
+    path: string,
+    payload?: unknown
+  ) =>
+    $fetch(`${base}${path}`, {
+      method,
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      ...(payload === undefined ? {} : { 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 fields: Record<string, unknown> = {};
+  if (body.status !== undefined) fields.status = body.status;
+  if (body.category !== undefined) fields.category = body.category;
+  if (Object.keys(fields).length) await write("PATCH", `/items/Notes/${body.id}`, fields);
+
+  for (const translation of body.translations ?? []) {
+    const payload: Record<string, unknown> = {};
+    if (translation.title !== undefined) payload.title = translation.title;
+    if (translation.summary !== undefined) payload.summary = translation.summary;
+    if (translation.sections !== undefined) {
+      payload.content = serializeNoteContent(translation.sections as NoteSection[]);
+    }
+    if (!Object.keys(payload).length) continue;
+
+    if (translation.id) {
+      await write("PATCH", `/items/Notes_translations/${translation.id}`, payload);
+    } else {
+      await write("POST", "/items/Notes_translations", {
+        ...payload,
+        Notes_id: body.id,
+        languages_code: translation.languages_code,
+      });
+    }
+  }
+
+  if (body.subjects || body.sources) {
+    const current = await $fetch<{ data: any }>(`${readUrl}/items/Notes/${body.id}`, {
+      headers: { Authorization: `Bearer ${readToken}`, "Cache-Control": "no-store" },
+      query: {
+        fields: [
+          "linked_subjects.id",
+          "linked_subjects.OipSubject_subject_id",
+          "linked_sources.id",
+          "linked_sources.DataSource_source_uuid",
+        ].join(","),
+      },
+    });
+
+    await syncLinks({
+      write,
+      collection: "Notes_OipSubject",
+      column: "OipSubject_subject_id",
+      noteId: body.id,
+      wanted: body.subjects,
+      existing: (current.data?.linked_subjects ?? []).map((link: any) => ({
+        linkId: link.id,
+        value: link.OipSubject_subject_id,
+      })),
+    });
+
+    await syncLinks({
+      write,
+      collection: "Notes_DataSource",
+      column: "DataSource_source_uuid",
+      noteId: body.id,
+      wanted: body.sources,
+      existing: (current.data?.linked_sources ?? []).map((link: any) => ({
+        linkId: link.id,
+        value: link.DataSource_source_uuid,
+      })),
+    });
+  }
+
+  return { ok: true };
+});
+
+/** Les lignes de liaison d'une collection, alignees sur ce que l'editeur montre. */
+async function syncLinks(options: {
+  write: (method: "PATCH" | "POST" | "DELETE", path: string, payload?: unknown) => Promise<unknown>;
+  collection: string;
+  column: string;
+  noteId: string;
+  wanted?: string[];
+  existing: { linkId: number; value: string }[];
+}) {
+  const { write, collection, column, noteId, wanted, existing } = options;
+  if (!wanted) return;
+
+  const keep = new Set(wanted);
+  const held = new Set(existing.map((link) => link.value));
+
+  const remove = existing.filter((link) => !keep.has(link.value)).map((link) => link.linkId);
+  if (remove.length) await write("DELETE", `/items/${collection}`, remove);
+
+  const add = wanted.filter((value) => !held.has(value));
+  for (const value of add) {
+    await write("POST", `/items/${collection}`, { Notes_id: noteId, [column]: value });
+  }
+}

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

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { defineEventHandler } from "h3";
+import {
+  assertOipSuperAdmin as assertSuperAdmin,
+  oipCheckRateLimit as checkRateLimit,
+  oipClientIp as getClientIp,
+  oipValidateBody as validateBody,
+} from "../../utils/oipGuards";
+
+/**
+ * PATCH /api/oip/sources, servi par le layer OIP (panneau « Sources »).
+ *
+ * Correction du referentiel de sources depuis le panneau « Sources » du rail.
+ *
+ * Trois ecritures independantes, sur trois collections Directus : la fiche elle
+ * meme (lien, frequence), sa traduction dans une langue (nom, description) et
+ * la traduction du fournisseur (nom, description). Une traduction absente est
+ * creee, une traduction existante est corrigee : le referentiel est presque
+ * entierement anglais, et une source internationale n'a souvent que ca.
+ *
+ * L'autorisation est revalidee ICI, pas seulement a l'affichage du crayon :
+ * cacher un bouton ne protege rien, la requete se fabrique a la main. Le droit
+ * est le meme que celui de la console d'OIP 7 (`/superadmin/me`), demande avec
+ * le jeton de l'utilisateur, jamais avec celui du serveur.
+ *
+ * Le jeton Directus d'ecriture est distinct de celui des rapports : il ne porte
+ * que `update` sur les sources et les fournisseurs, plus `create` sur leurs
+ * traductions, sans droit de suppression, pour qu'une faiblesse ailleurs dans
+ * l'app ne puisse pas devenir une ecriture libre dans le referentiel partage
+ * par toutes les apps pays.
+ */
+/**
+ * Langues ouvertes a la saisie. Une liste fermee, pas le contenu de la table
+ * `languages` : le referentiel porte des codes abimes (un `ja-JP` suivi d'une
+ * tabulation) qu'il ne faut pas propager, et rien ne justifie de creer une
+ * traduction dans une langue qu'aucune app ne lit.
+ */
+const LANGUAGES = ["en-US", "fr-FR", "es-ES", "de-DE", "ja-JP", "ko-KR"] as const;
+
+/** Corriger demande un id, creer demande une langue. L'un ou l'autre. */
+const target = { id: z.number().int().positive().optional(), languages_code: z.enum(LANGUAGES).optional() };
+const hasTarget = (t: { id?: number; languages_code?: string }) => !!t.id || !!t.languages_code;
+
+const schema = z.object({
+  uuid: z.string().uuid(),
+  /** Necessaire pour creer une traduction de fournisseur. */
+  providerUuid: z.string().uuid().optional(),
+  source: z
+    .object({
+      source_link: z.string().url().max(500).nullable().optional(),
+      update_frequency: z.string().max(50).nullable().optional(),
+    })
+    .optional(),
+  translation: z
+    .object({
+      ...target,
+      source_name: z.string().max(300).nullable().optional(),
+      source_description: z.string().max(20000).nullable().optional(),
+    })
+    .refine(hasTarget, { message: "translation needs an id or a languages_code" })
+    .optional(),
+  providerTranslation: z
+    .object({
+      ...target,
+      provider_name: z.string().max(300).nullable().optional(),
+      provider_description: z.string().max(20000).nullable().optional(),
+    })
+    .refine(hasTarget, { message: "providerTranslation needs an id or a languages_code" })
+    .optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  checkRateLimit(`sources-write:${getClientIp(event)}`, 30, 15 * 60 * 1000);
+
+  await assertSuperAdmin(event);
+
+  const body = await validateBody(event, schema);
+  const config = useRuntimeConfig();
+
+  const base = (config.directusSourcesWriteUrl as string | undefined)?.replace(/\/$/, "");
+  const token = config.directusSourcesWriteToken as string | undefined;
+  if (!base || !token) {
+    throw createError({ status: 500, message: "Directus write credentials are not configured" });
+  }
+
+  // Un champ absent du corps n'est pas efface : seules les cles envoyees
+  // partent a Directus.
+  const sourceFields = Object.fromEntries(
+    Object.entries(body.source ?? {}).filter(([, v]) => v !== undefined)
+  );
+  const textFields = (input: Record<string, unknown> | undefined) =>
+    Object.fromEntries(
+      Object.entries(input ?? {}).filter(
+        ([k, v]) => k !== "id" && k !== "languages_code" && v !== undefined
+      )
+    );
+  const translationFields = textFields(body.translation);
+  const providerFields = textFields(body.providerTranslation);
+
+  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 patch = (path: string, payload: Record<string, unknown>) =>
+    write("PATCH", path, payload);
+
+  if (Object.keys(sourceFields).length) {
+    await patch(`/items/DataSource/${body.uuid}`, sourceFields);
+  }
+  if (body.translation && Object.keys(translationFields).length) {
+    if (body.translation.id) {
+      await patch(`/items/DataSource_translations/${body.translation.id}`, translationFields);
+    } else {
+      await write("POST", "/items/DataSource_translations", {
+        ...translationFields,
+        DataSource_source_uuid: body.uuid,
+        languages_code: body.translation.languages_code,
+      });
+    }
+  }
+
+  if (body.providerTranslation && Object.keys(providerFields).length) {
+    if (body.providerTranslation.id) {
+      await patch(
+        `/items/DataProvider_translations/${body.providerTranslation.id}`,
+        providerFields
+      );
+    } else if (body.providerUuid) {
+      await write("POST", "/items/DataProvider_translations", {
+        ...providerFields,
+        DataProvider_provider_uuid: body.providerUuid,
+        languages_code: body.providerTranslation.languages_code,
+      });
+    }
+  }
+
+  return { ok: true };
+});

package/layer/server/api/oip/sources.post.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { defineEventHandler } from "h3";
+import {
+  oipCheckRateLimit as checkRateLimit,
+  oipClientIp as getClientIp,
+  oipValidateBody as validateBody,
+} from "../../utils/oipGuards";
+
+/**
+ * POST /api/oip/sources, servi par le layer OIP (panneau « Sources »).
+ *
+ * Sources proxy — resolves source_uuids to their Directus DataSource records
+ * (name, description, provider, latest_download_date, update_frequency,
+ * tags_terms, provider sector + ISO country) so the client never sees the
+ * Directus URL or token. Directus creds come from server env; the browser only
+ * ever talks to /api/sources.
+ */
+const schema = z.object({
+  uuids: z.array(z.string().uuid()).min(1).max(100),
+});
+
+const SOURCES_QUERY = `
+  query Sources($uuids: [ID!]) {
+    DataSource(filter: { source_uuid: { _in: $uuids } }) {
+      source_uuid
+      Nickname
+      source_link
+      latest_download_date
+      source_last_updated
+      update_frequency
+      translations {
+        id
+        languages_code
+        source_name
+        source_description
+      }
+      tags_terms
+      provider {
+        provider_uuid
+        provider_country
+        status
+        geo_zones {
+          country_label
+          country_iso
+        }
+        translations {
+          id
+          languages_code
+          provider_name
+          provider_description
+        }
+      }
+    }
+  }
+`;
+
+export default defineEventHandler(async (event) => {
+  checkRateLimit(`sources:${getClientIp(event)}`, 60, 15 * 60 * 1000);
+
+  const { uuids } = await validateBody(event, schema);
+  const config = useRuntimeConfig();
+
+  const url =
+    (config.directusUrl as string) ||
+    "https://metadata.rcd.lensuscloud.com/graphql";
+  const token = config.directusToken as string | undefined;
+
+  const response = await $fetch<{ data?: { DataSource?: any[] }; errors?: any[] }>(
+    url,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      },
+      body: { query: SOURCES_QUERY, variables: { uuids } },
+    }
+  );
+
+  if (response.errors?.length) {
+    throw createError({
+      status: 502,
+      message: `Directus query failed: ${response.errors[0]?.message ?? "unknown error"}`,
+    });
+  }
+
+  return { sources: response.data?.DataSource ?? [] };
+});

package/layer/server/api/oip/table-groups.get.ts

@@ -0,0 +1,145 @@
+import { defineEventHandler } from "h3";
+import { oipAppUrls } from "../../utils/oipGuards";
+import type { SubjectTableGroups, TableGroup } from "../../../app/types/tableGroups";
+
+/**
+ * GET /api/oip/table-groups, servi par le layer OIP (panneau « Sources »).
+ *
+ * Les tablegroups Directus rattaches aux sujets de cette app, pour l'onglet
+ * « Tables » du panneau Sources du rail.
+ *
+ * Un sujet (`OipSubject`, un par ecran) cite ses `TableGroups` par la liaison
+ * `OipSubject_TableGroups` ; un tablegroup regroupe des `Dataset`, une table
+ * Redshift chacun.
+ *
+ * La reponse sort entiere, comme les notes : le choix du sujet de l'ecran
+ * ouvert se fait cote client, qui seul sait quelle page est ouverte.
+ *
+ * Le jeton peut lire la liaison sans lire `TableGroups` : les tablegroups
+ * sortent alors avec leur seul identifiant, et `readable` le dit au panneau.
+ */
+
+
+export default defineEventHandler(async (): Promise<{ readable: boolean; subjects: SubjectTableGroups[] }> => {
+  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: "Table groups are not configured" });
+  }
+
+  const headers = { Authorization: `Bearer ${token}` };
+
+  const subjects = await $fetch<{ data: any[] }>(`${url}/items/OipSubject`, {
+    headers,
+    query: {
+      limit: -1,
+      filter: JSON.stringify({ app: { prod_url: { _in: oipAppUrls() } } }),
+      fields: "relative_path,table_group.TableGroups_id",
+    },
+  });
+
+  const rows = (subjects.data ?? []).map((row) => ({
+    relative_path: String(row.relative_path ?? ""),
+    ids: (row.table_group ?? [])
+      .map((link: any) => link?.TableGroups_id)
+      .filter((id: unknown): id is string => typeof id === "string" && !!id),
+  }));
+
+  const ids = [...new Set(rows.flatMap((row) => row.ids))];
+  const byId = new Map<string, TableGroup>();
+  let readable = true;
+
+  if (ids.length) {
+    try {
+      const groups = await $fetch<{ data: any[] }>(`${url}/items/TableGroups`, {
+        headers,
+        query: {
+          limit: -1,
+          filter: JSON.stringify({ id: { _in: ids } }),
+          fields: [
+            "id",
+            "title",
+            "short_description",
+            "Category",
+            "status",
+            "date_updated",
+            "data_packages.DataPackage_id",
+            "data_packages.link_tags",
+            "data_packages.link_summary",
+            "datasets.Dataset_id.schema_name",
+            "datasets.Dataset_id.table_name",
+            "datasets.Dataset_id.nickname",
+            "datasets.Dataset_id.short_description",
+            "datasets.Dataset_id.last_update",
+            "datasets.Dataset_id.update_frequency",
+            "datasets.Dataset_id.start_period",
+            "datasets.Dataset_id.end_period",
+            "datasets.Dataset_id.location",
+            "datasets.Dataset_id.geographical_scope",
+            "datasets.Dataset_id.geographical_granularity",
+          ].join(","),
+        },
+      });
+      for (const g of groups.data ?? []) {
+        byId.set(g.id, {
+          id: g.id,
+          title: g.title ?? "",
+          short_description: g.short_description ?? "",
+          category: g.Category ?? "",
+          status: g.status ?? "",
+          date_updated: g.date_updated ?? null,
+          packages: (g.data_packages ?? []).map((link: any) => ({
+            id: String(link?.DataPackage_id ?? ""),
+            name: "",
+            tags: Array.isArray(link?.link_tags) ? link.link_tags : [],
+            summary: link?.link_summary ?? "",
+          })),
+          datasets: (g.datasets ?? [])
+            .map((link: any) => link?.Dataset_id)
+            .filter((d: any) => d && typeof d === "object")
+            .map((d: any) => ({
+              schema_name: d.schema_name ?? "",
+              table_name: d.table_name ?? "",
+              nickname: d.nickname ?? "",
+              short_description: d.short_description ?? "",
+              last_update: d.last_update ?? null,
+              update_frequency: d.update_frequency ?? "",
+              start_period: d.start_period ?? null,
+              end_period: d.end_period ?? null,
+              location: typeof d.location === "string" ? d.location : "",
+              geographical_scope: d.geographical_scope ?? "",
+              geographical_granularity: d.geographical_granularity ?? "",
+            })),
+        });
+      }
+    } catch (err: any) {
+      if (err?.statusCode !== 403 && err?.status !== 403) throw err;
+      readable = false;
+    }
+  }
+
+  // Le nom des data packages, s'il est lisible : sans droit sur `DataPackage`,
+  // demander `DataPackage_id.*` effacerait le lien entier, d'ou un appel a part.
+  const packageIds = [...new Set([...byId.values()].flatMap((g) => g.packages.map((p) => p.id)).filter(Boolean))];
+  if (packageIds.length) {
+    try {
+      const packages = await $fetch<{ data: any[] }>(`${url}/items/DataPackage`, {
+        headers,
+        query: { limit: -1, filter: JSON.stringify({ id: { _in: packageIds } }) },
+      });
+      const names = new Map((packages.data ?? []).map((p) => [String(p.id), String(p.title ?? p.name ?? p.package_name ?? "")]));
+      for (const g of byId.values()) for (const p of g.packages) p.name = names.get(p.id) ?? "";
+    } catch (err: any) {
+      if (err?.statusCode !== 403 && err?.status !== 403) throw err;
+    }
+  }
+
+  return {
+    readable,
+    subjects: rows.map((row) => ({
+      relative_path: row.relative_path,
+      groups: row.ids.map((id: string) => byId.get(id) ?? { id, title: "", short_description: "", category: "", status: "", date_updated: null, packages: [], datasets: [] }),
+    })),
+  };
+});

package/layer/server/api/oip/tutorial-video.get.ts

@@ -0,0 +1,44 @@
+import { defineEventHandler } from "h3";
+
+/**
+ * GET /api/oip/tutorial-video, servi par le layer OIP (panneau « Tutoriels »).
+ *
+ * Resout la video de prise en main OIP 7 (collection Directus OipTutorials).
+ * L'element vient de `runtimeConfig.oipTutorialVideoId` (env
+ * NUXT_OIP_TUTORIAL_VIDEO_ID, ou DIRECTUS_VIDEO_TUTORIAL_ID) : sans lui, pas
+ * de video, le panneau n'affiche que les visites.
+ *
+ * Le navigateur ne voit ni l'URL Directus ni son token : il recoit l'URL du
+ * proxy /api/oip/asset qui sert le fichier.
+ */
+export default defineEventHandler(async () => {
+  const config = useRuntimeConfig();
+  const id = config.oipTutorialVideoId || process.env.DIRECTUS_VIDEO_TUTORIAL_ID;
+  if (!id) return null;
+
+  const base = (config.directusVideoTutorialsUrl as string | undefined)?.replace(/\/+$/, "");
+  const token = config.directusVideoTutorialsToken as string | undefined;
+  if (!base || !token) {
+    throw createError({
+      status: 503,
+      message: "Tutorial video is not configured: set DIRECTUS_URL and DIRECTUS_TOKEN",
+    });
+  }
+
+  const response = await $fetch<{ data?: any }>(`${base}/items/OipTutorials/${id}`, {
+    headers: { Authorization: `Bearer ${token}` },
+    query: { "fields[]": ["id", "Title", "description", "video.directus_files_id"] },
+  });
+
+  const item = response.data;
+  const video = Array.isArray(item?.video) ? item.video[0] : item?.video;
+  const fileId = typeof video === "string" ? video : video?.directus_files_id;
+  if (!fileId) return null;
+
+  return {
+    id: item.id,
+    title: item.Title ?? "",
+    description: item.description ?? "",
+    src: `/api/oip/asset/${fileId}`,
+  };
+});

package/layer/server/api/romulus/version.get.ts

@@ -0,0 +1,4 @@
+import pkg from '../../../../package.json'
+
+// Indique quelle version de Romulus (et donc du layer) tourne dans une app.
+export default defineEventHandler(() => ({ version: pkg.version }))