@tekkare/romulus 0.1.241 → 0.1.243

package/layer/server/utils/oipAuth.ts

@@ -0,0 +1,69 @@
+import type { H3Event } from "h3";
+import { getCookie, parseCookies } from "h3";
+
+// Identification de l'appelant pour les routes /api/oip/* du layer. Prefixees
+// `oip` : les apps ont leurs propres helpers (getAccessToken, requireSession)
+// et les utils serveur sont auto-importes, deux noms identiques se
+// masqueraient.
+
+/**
+ * Jeton d'acces de la session (FusionAuth via @sidebase/nuxt-auth).
+ *
+ * getServerSession d'abord ; a defaut, decodage du cookie de session. Son nom
+ * est propre a chaque app (`france-drugs.session-token`...) : il se regle par
+ * `runtimeConfig.oipSessionCookie`, sinon on prend le premier cookie qui finit
+ * par `.session-token`.
+ */
+export async function getOipAccessToken(event: H3Event): Promise<string | null> {
+  try {
+    const { getServerSession } = await import("#auth");
+    const session = await getServerSession(event);
+    if ((session as any)?.accessToken) return (session as any).accessToken;
+  } catch {
+    // getServerSession indisponible : on passe au decodage du cookie.
+  }
+
+  try {
+    const { decode } = await import("next-auth/jwt");
+    const secret = process.env.NEXTAUTH_SECRET || process.env.AUTH_SECRET;
+    const name =
+      (useRuntimeConfig().oipSessionCookie as string | undefined) ||
+      Object.keys(parseCookies(event)).find((key) => key.endsWith(".session-token"));
+    const sessionToken = name ? getCookie(event, name) : undefined;
+    if (sessionToken && secret) {
+      const decoded = await decode({ token: sessionToken, secret });
+      return (decoded?.accessToken as string) || null;
+    }
+  } catch {
+    // Decodage impossible : pas de session.
+  }
+
+  return null;
+}
+
+/** Une session signee existe, sans demander a la Virtual Lab qui elle est. */
+export async function requireOipSession(event: H3Event): Promise<string> {
+  const token = await getOipAccessToken(event);
+  if (!token) throw createError({ status: 401, message: "Authentication required" });
+  return token;
+}
+
+/**
+ * L'identifiant de l'appelant, demande a la Virtual Lab API avec son propre
+ * jeton, jamais lu dans la requete : personne ne lit la liste d'un autre.
+ */
+export async function requireOipUserId(event: H3Event): Promise<string> {
+  const token = await requireOipSession(event);
+  const base = useRuntimeConfig().public.apiBase as string;
+  let me: { user?: { userId?: string } };
+  try {
+    me = await $fetch<{ user?: { userId?: string } }>(`${base}/me/summary`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+  } catch {
+    throw createError({ status: 403, message: "Could not identify the caller" });
+  }
+  const userId = me?.user?.userId;
+  if (!userId) throw createError({ status: 403, message: "Could not identify the caller" });
+  return userId;
+}

package/layer/server/utils/oipEsIndices.ts

@@ -0,0 +1,99 @@
+// Registre des index Elasticsearch, lu dans la collection Directus
+// `ElasticIndices`. Une app designe un index par l'`id` Directus de sa ligne :
+// il ne change jamais, alors que le nom physique suit les versions (`_v2`),
+// les alias et la bascule staging. La resolution se fait ici, cote serveur,
+// au moment d'interroger le cluster.
+
+export interface OipEsIndexRow {
+  id: string;
+  canonical_name: string;
+  physical_index: string;
+  staging_physical: string | null;
+  status: string | null;
+}
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** Statuts qui ne doivent plus etre interroges. */
+const RETIRED = new Set(["candidate-for-deletion", "orphan-staging"]);
+
+/** Cinq minutes : une bascule de version arrive vite sans marteler Directus. */
+const TTL_MS = 5 * 60 * 1000;
+
+let cache: { at: number; byId: Map<string, OipEsIndexRow>; byName: Map<string, OipEsIndexRow> } | null = null;
+let inflight: Promise<void> | null = null;
+
+export const isOipEsIndexId = (ref: string) => UUID.test(ref);
+
+async function load() {
+  const config = useRuntimeConfig();
+  const url = ((config.oipEsIndicesUrl as string) || "").replace(/\/+$/, "");
+  const token = config.oipEsIndicesToken as string;
+  if (!url || !token) {
+    throw createError({
+      status: 503,
+      message: "Elastic indices registry is not configured: set NUXT_OIP_ES_INDICES_URL and NUXT_OIP_ES_INDICES_TOKEN",
+    });
+  }
+  const response = await $fetch<{ data: OipEsIndexRow[] }>(`${url}/items/ElasticIndices`, {
+    headers: { Authorization: `Bearer ${token}` },
+    query: { limit: -1, fields: "id,canonical_name,physical_index,staging_physical,status" },
+  });
+  const rows = response.data ?? [];
+  const byId = new Map(rows.map((row) => [row.id, row]));
+  const byName = new Map<string, OipEsIndexRow>();
+  for (const row of rows) {
+    byName.set(row.physical_index, row);
+    byName.set(row.canonical_name, row);
+  }
+  cache = { at: Date.now(), byId, byName };
+}
+
+/**
+ * Le registre, recharge au plus toutes les cinq minutes. Si Directus ne
+ * repond pas, l'ancien registre continue de servir : une panne du CMS ne doit
+ * pas couper les donnees.
+ */
+export async function oipEsIndexRegistry() {
+  if (cache && Date.now() - cache.at < TTL_MS) return cache;
+  inflight ??= load()
+    .catch((error) => {
+      if (!cache) throw error;
+    })
+    .finally(() => {
+      inflight = null;
+    });
+  await inflight;
+  return cache!;
+}
+
+/** La ligne d'un index, par id Directus ou par nom (canonique ou physique). */
+export async function findOipEsIndex(ref: string): Promise<OipEsIndexRow | undefined> {
+  const registry = await oipEsIndexRegistry();
+  return isOipEsIndexId(ref) ? registry.byId.get(ref) : registry.byName.get(ref);
+}
+
+/**
+ * Le nom a interroger pour une reference : l'index physique, ou sa copie de
+ * staging quand `runtimeConfig.oipEsIndicesStaging` est vrai et qu'elle
+ * existe. Un id inconnu ou un index retire est refuse ; un nom absent du
+ * registre passe tel quel (index pas encore declares dans Directus).
+ */
+export async function resolveOipEsIndex(ref: string): Promise<string> {
+  const row = await findOipEsIndex(ref);
+  if (!row) {
+    if (isOipEsIndexId(ref)) throw createError({ status: 400, message: `Unknown index id: ${ref}` });
+    return ref;
+  }
+  if (row.status && RETIRED.has(row.status)) {
+    throw createError({ status: 410, message: `Index retired: ${row.canonical_name}` });
+  }
+  const staging = !!useRuntimeConfig().oipEsIndicesStaging;
+  return (staging && row.staging_physical) || row.physical_index;
+}
+
+/** Plusieurs references separees par des virgules, comme l'URL d'Elasticsearch. */
+export async function resolveOipEsIndexList(refs: string): Promise<string> {
+  const names = await Promise.all(refs.split(",").map((ref) => resolveOipEsIndex(ref.trim())));
+  return names.join(",");
+}

package/layer/server/utils/oipGuards.ts

@@ -0,0 +1,90 @@
+import type { H3Event } from "h3";
+import type { z } from "zod";
+import { getOipAccessToken } from "./oipAuth";
+
+// Garde-fous partages par les routes d'ecriture /api/oip/*. Prefixes `oip`
+// pour ne pas masquer les helpers des apps (utils serveur auto-importes).
+
+/**
+ * Le droit d'administration, celui de la console d'OIP 7 (`/superadmin/me`),
+ * demande avec le jeton de l'utilisateur et revalide a chaque requete :
+ * cacher un crayon dans l'interface ne protege rien.
+ *
+ * L'URL de la Virtual Lab vient de `runtimeConfig.oipVirtualLabApiUrl`, sinon
+ * de l'env VIRTUAL_LAB_API_URL.
+ */
+export async function assertOipSuperAdmin(event: H3Event) {
+  const token = await getOipAccessToken(event);
+  if (!token) throw createError({ status: 401, message: "Not authenticated" });
+
+  const apiUrl = (useRuntimeConfig().oipVirtualLabApiUrl as string) || process.env.VIRTUAL_LAB_API_URL;
+  if (!apiUrl) throw createError({ status: 500, message: "VIRTUAL_LAB_API_URL is not set" });
+
+  let isSuperAdmin = false;
+  try {
+    const me = await $fetch<{ isSuperAdmin?: boolean }>(`${apiUrl}/superadmin/me`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    isSuperAdmin = !!me?.isSuperAdmin;
+  } catch {
+    isSuperAdmin = false;
+  }
+  if (!isSuperAdmin) throw createError({ status: 403, message: "Superadmin required" });
+}
+
+/**
+ * Les `prod_url` de l'app dans le portail OIP 7 (fiche OipApplication) : la
+ * collection est commune a tout le portail, une app s'y reconnait par la.
+ * `runtimeConfig.oipAppUrl`, sinon l'env NOTES_APP_URL ; plusieurs URL
+ * separees par des virgules, la premiere designe la fiche corrigee. Pas de
+ * valeur par defaut : une app mal reglee lirait les notes d'une autre.
+ */
+export function oipAppUrls(): string[] {
+  const raw = (useRuntimeConfig().oipAppUrl as string) || process.env.NOTES_APP_URL || "";
+  const urls = raw
+    .split(",")
+    .map((url) => url.trim().replace(/\/+$/, ""))
+    .filter(Boolean);
+  if (!urls.length) {
+    throw createError({ status: 500, message: "App URL is not set: NUXT_OIP_APP_URL or NOTES_APP_URL" });
+  }
+  return urls;
+}
+
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
+
+export function oipCheckRateLimit(key: string, maxAttempts: number, windowMs: number): void {
+  const now = Date.now();
+  const entry = rateLimitMap.get(key);
+  if (entry && now < entry.resetAt) {
+    if (entry.count >= maxAttempts) {
+      throw createError({ status: 429, message: "Too many requests. Please try again later." });
+    }
+    entry.count++;
+  } else {
+    rateLimitMap.set(key, { count: 1, resetAt: now + windowMs });
+  }
+  if (rateLimitMap.size > 10000) {
+    for (const [k, v] of rateLimitMap) {
+      if (now > v.resetAt) rateLimitMap.delete(k);
+    }
+  }
+}
+
+/** Dernier saut de X-Forwarded-For : le seul ecrit par notre ingress. */
+export function oipClientIp(event: H3Event): string {
+  const hops = getRequestHeader(event, "x-forwarded-for")
+    ?.split(",")
+    .map((h) => h.trim())
+    .filter(Boolean);
+  return hops?.pop() || getRequestIP(event) || "unknown";
+}
+
+export async function oipValidateBody<T>(event: H3Event, schema: z.ZodSchema<T>): Promise<T> {
+  const body = await readBody(event);
+  const result = schema.safeParse(body);
+  if (!result.success) {
+    throw createError({ status: 400, message: result.error.issues[0]?.message || "Invalid input" });
+  }
+  return result.data;
+}

package/layer/server/utils/oipNoteMarkup.ts

@@ -0,0 +1,197 @@
+/**
+ * Le balisage des notes Directus, converti en blocs pour RmNotes.
+ *
+ * Directus ne stocke qu'un texte. Le panneau, lui, rend des blocs typés : un
+ * encadre, un exemple, une liste, une liste de definitions. Plutot que de
+ * demander un JSON a l'editeur, le texte porte des marqueurs que ce module
+ * traduit.
+ *
+ * Un marqueur ouvre le paragraphe et vaut jusqu'a la ligne vide :
+ *
+ *   [info] Le taux reel inclut la prise en charge ALD.
+ *   [warning] Les acces precoces n'ont pas d'ASMR.
+ *   [example] Y = ((94% - 65%) / (100% - 65%))
+ *
+ * Le fond et l'icone viennent du ton : bleu et « i » pour [info], ambre et
+ * triangle pour [warning]. La couleur ne dit jamais la nature toute seule.
+ *
+ * Tout ce qui n'est pas reconnu reste du paragraphe : une note mal balisee
+ * s'affiche en texte, jamais en code.
+ */
+import type { NoteBlock, NoteSection } from "../../app/notes/types";
+
+/** Marqueurs d'encadre, avec leurs alias. Le ton decide du fond et de l'icone. */
+const CALLOUTS: Record<string, "info" | "warning"> = {
+  info: "info",
+  tips: "info",
+  astuce: "info",
+  warning: "warning",
+  attention: "warning",
+  limite: "warning",
+};
+
+const MARKER_LINE = /^\[(info|tips|astuce|warning|attention|limite|example|exemple)\]\s*(.*)$/i;
+const LINK_TAG = /^<(?:link|lien)\s+to="([^"]+)"\s*>([\s\S]*?)<\/(?:link|lien)>$/i;
+const SECTION_LINE = /^##\s+(.*)$/;
+const BULLET_LINE = /^[•*\-–]\s+(.*)$/;
+const TERM_LINE = /^\*\*(.+?)\*\*\s*[:：]\s*(.*)$/;
+
+/** Un morceau du texte : soit un titre de section, soit un bloc rendu. */
+type Piece = { section: string } | { block: NoteBlock };
+
+/**
+ * Le texte d'une note, decoupe en sections.
+ *
+ * Les blocs arrivent dans l'ordre d'ecriture ; un `## Titre` ouvre une
+ * section, et ce qui precede le premier titre forme la section d'entete.
+ */
+export function oipParseNoteContent(raw: string): NoteSection[] {
+  return fold(parseLines((raw ?? "").replace(/\r\n?/g, "\n")));
+}
+
+/** Le texte ligne a ligne : marqueurs, titres de section, listes, renvois. */
+function parseLines(text: string): Piece[] {
+  const pieces: Piece[] = [];
+  let list: string[] = [];
+  let terms: { term: string; def?: string }[] = [];
+  let paragraph: string[] = [];
+  /** Marqueur ouvert : il tient jusqu'a la ligne vide, ou jusqu'a un autre bloc. */
+  let marker: string | null = null;
+
+  const flush = () => {
+    if (list.length) pieces.push({ block: { type: "list", items: list } });
+    if (terms.length) pieces.push({ block: { type: "terms", items: terms } });
+    if (paragraph.length) pieces.push({ block: paragraphBlock(paragraph.join(" "), marker) });
+    list = [];
+    terms = [];
+    paragraph = [];
+    marker = null;
+  };
+
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) {
+      flush();
+      continue;
+    }
+
+    // Un marqueur ferme ce qui precede : deux encadres de suite restent deux
+    // encadres, meme colles.
+    const mark = line.match(MARKER_LINE);
+    if (mark) {
+      flush();
+      marker = mark[1]!.toLowerCase();
+      if (mark[2]!.trim()) paragraph.push(mark[2]!.trim());
+      continue;
+    }
+
+    const section = line.match(SECTION_LINE);
+    if (section) {
+      flush();
+      pieces.push({ section: section[1]!.trim() });
+      continue;
+    }
+
+    const link = line.match(LINK_TAG);
+    if (link) {
+      flush();
+      pieces.push({ block: { type: "link", to: link[1]!, label: link[2]!.trim() } });
+      continue;
+    }
+
+    const bullet = line.match(BULLET_LINE);
+    if (bullet) {
+      if (paragraph.length || terms.length) flush();
+      list.push(bullet[1]!.trim());
+      continue;
+    }
+
+    // Une definition ne se reconnait qu'en debut de ligne : « **Terme** : sens ».
+    const term = line.match(TERM_LINE);
+    if (term) {
+      if (paragraph.length || list.length) flush();
+      terms.push({ term: term[1]!.trim(), ...(term[2]!.trim() ? { def: term[2]!.trim() } : {}) });
+      continue;
+    }
+
+    if (list.length || terms.length) flush();
+    paragraph.push(line);
+  }
+
+  flush();
+  return pieces;
+}
+
+/** Le paragraphe courant, selon le marqueur qui l'a ouvert. */
+function paragraphBlock(text: string, marker: string | null): NoteBlock {
+  if (!marker) return { type: "text", text };
+  if (marker === "example" || marker === "exemple") return { type: "example", text };
+  return { type: "callout", tone: CALLOUTS[marker] ?? "info", text };
+}
+
+/** Les morceaux regroupes par section. Une section vide ne sort pas. */
+function fold(pieces: Piece[]): NoteSection[] {
+  const sections: NoteSection[] = [];
+  let current: NoteSection = { blocks: [] };
+
+  for (const piece of pieces) {
+    if ("section" in piece) {
+      if (current.blocks.length) sections.push(current);
+      current = { title: piece.section, blocks: [] };
+      continue;
+    }
+    current.blocks.push(piece.block);
+  }
+  if (current.blocks.length) sections.push(current);
+
+  return sections;
+}
+
+/**
+ * Le chemin inverse : des blocs vers le texte balise que Directus stocke.
+ *
+ * L'editeur du panneau travaille sur des blocs ; le CMS, lui, garde un texte,
+ * relisible et corrigeable dans son propre editeur. Les deux fonctions vont
+ * ensemble : ce que `serializeNoteContent` ecrit, `parseNoteContent` doit le
+ * relire a l'identique, sans quoi une note corrigee depuis l'app changerait de
+ * forme au rechargement.
+ *
+ * Un bloc par paragraphe, separes par une ligne vide : c'est ce qui ferme un
+ * marqueur ouvert, et ce qui empeche deux encadres de se fondre en un seul.
+ */
+export function oipSerializeNoteContent(sections: NoteSection[]): string {
+  const parts: string[] = [];
+
+  for (const section of sections ?? []) {
+    if (section.title?.trim()) parts.push(`## ${section.title.trim()}`);
+    for (const block of section.blocks ?? []) {
+      const text = serializeBlock(block);
+      if (text) parts.push(text);
+    }
+  }
+
+  return parts.join("\n\n");
+}
+
+function serializeBlock(block: NoteBlock): string {
+  switch (block.type) {
+    case "text":
+      return block.text.trim();
+    // Les entrees d'une liste se suivent sans ligne vide : une coupure ferait
+    // deux listes.
+    case "list":
+      return block.items.map((item) => `• ${item.trim()}`).join("\n");
+    case "terms":
+      return block.items
+        .map((item) => `**${item.term.trim()}** : ${(item.def ?? "").trim()}`)
+        .join("\n");
+    case "callout":
+      return `[${block.tone === "warning" ? "warning" : "info"}] ${block.text.trim()}`;
+    case "example":
+      return `[example] ${block.text.trim()}`;
+    case "link":
+      return `<link to="${block.to.trim()}">${block.label.trim()}</link>`;
+    default:
+      return "";
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.241",
+  "version": "0.1.243",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",
@@ -16,13 +16,16 @@
     "./utils/*": {
       "types": "./dist/runtime/utils/*.d.ts",
       "import": "./dist/runtime/utils/*.js"
-    }
+    },
+    "./layer": "./layer/nuxt.config.ts",
+    "./layer-utils/*": "./layer/app/utils/*.ts"
   },
   "main": "./dist/module.cjs",
   "module": "./dist/module.mjs",
   "types": "./dist/types.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "layer"
   ],
   "scripts": {
     "build": "nuxt-module-build build",