@tekkare/romulus 0.1.243 → 0.1.245

package/layer/app/utils/viewTemplates.ts

@@ -0,0 +1,116 @@
+/**
+ * viewTemplates - les vues prêtes a l'emploi fournies par Tekkare.
+ *
+ * Un template est une vue que personne n'a enregistree : un jeu de criteres
+ * ecrit ici, applique comme une vue temporaire (sans identifiant, cf.
+ * `isTemporaryView`). L'utilisateur le demarre, le retouche, et l'enregistre
+ * dans ses vues s'il veut le garder. Rien ne part en base tant qu'il ne le
+ * demande pas.
+ *
+ * Les criteres se construisent avec la langue de l'ecran, jamais en dur :
+ * - les filtres tapent `status_fr` ou `status_en` selon la locale, et la vue
+ *   stocke le libelle affiche (« Insuffisant » / « Insufficient ») ;
+ * - un filtre booleen (`CheckFilter`) stocke `"<libelle du filtre>: true"`,
+ *   donc « Oncologie: true » en francais et « Oncology: true » en anglais ;
+ * - sur la page Prix, c'est le NOM du filtre qui est traduit.
+ * D'ou le contexte `{ lang, t }` passe a chaque `criteria()`.
+ *
+ * Les valeurs sont celles des index : elles ont ete relevees par agregation,
+ * pas devinees (cf. la page projet du vault). Une valeur inventee ne filtre
+ * rien et le template ouvre un ecran vide.
+ */
+
+import { VIEW_TEMPLATES } from "#oip-app/views";
+
+export type ViewTemplateTone = "primary" | "success" | "warning" | "danger" | "info";
+
+export interface ViewTemplateContext {
+  lang: "fr" | "en";
+  t: (key: string) => string;
+  /**
+   * Une cle i18n existe-t-elle. Les templates en dur n'en ont pas besoin
+   * (leurs cles sont ecrites ici, donc sures) ; ceux publies depuis l'app,
+   * si : ils relisent une cle rangee en base, qu'un renommage a pu perimer.
+   */
+  te: (key: string) => boolean;
+}
+
+/** Un critere de vue. `values` est un tableau, sauf pour la periode. */
+export interface ViewTemplateCriterion {
+  filter: string;
+  values: string[] | string;
+}
+
+export interface ViewTemplate {
+  /** Identifiant stable : il sert de cle de carte, jamais d'id de vue. */
+  id: string;
+  /** Chemin de la page, sans prefixe de langue ni barre finale. */
+  page: string;
+  /** Icone Phosphor de la pastille. */
+  icon: string;
+  tone?: ViewTemplateTone;
+  title: Record<"fr" | "en", string>;
+  description: Record<"fr" | "en", string>;
+  criteria: (ctx: ViewTemplateContext) => ViewTemplateCriterion[];
+  /**
+   * Le template se demarre par un lien profond plutot qu'en posant les
+   * criteres a l'ecran.
+   *
+   * Les pages du portail « Medicaments France » ne portent pas des filtres
+   * mais une selection de produits, et personne ne la resout dans la page :
+   * c'est le middleware `03.scope-from-query` qui expanse un code ATC en
+   * liste de marques, remplit les listes par source (`medicamBrandList`,
+   * `susBrandList`...) et pose la vue temporaire. Un template de panier est
+   * donc l'URL qui le declenche, ce qui evite d'y figer une liste de marques
+   * qui vieillirait a chaque nouvelle AMM.
+   */
+  deepLink?: boolean;
+  /**
+   * Publie pour l'espace du lecteur nommement, et non pour tout le monde :
+   * la carte le dit (« Créé pour vous »).
+   */
+  forYou?: boolean;
+}
+
+/**
+ * Parametre d'URL qui dit de quel template vient le perimetre pose. Le
+ * middleware du lien profond le recopie sur la vue temporaire, la pastille de
+ * la barre nomme alors le template plutot que de dire « Vue temporaire », et la
+ * navigation le garde avec les autres cles de perimetre (cf. useDrugsNav).
+ */
+export const VIEW_TEMPLATE_QUERY_PARAM = "template";
+
+/**
+ * Critere de vue vers parametre d'URL (template en lien profond) et
+ * parametres a nettoyer avant d'en poser de nouveaux : metier de l'app, cf.
+ * contrat #oip-app/views.
+ */
+export { VIEW_TEMPLATE_QUERY_KEYS, VIEW_TEMPLATE_QUERY_RESET } from "#oip-app/views";
+
+/**
+ * Chemin comparable : sans prefixe de langue (`/en/price`), sans barre finale.
+ * Les pages declarent `route.path`, qui porte les deux.
+ */
+export function normalizePage(path: string): string {
+  return String(path ?? "")
+    .replace(/^\/(?:en|fr)(?=\/|$)/, "")
+    .replace(/\/$/, "");
+}
+
+/**
+ * Un template du catalogue par identifiant, quelle que soit sa page : la
+ * pastille nomme le template dont vient la vue, et la vue suit le lecteur
+ * d'une page du portail a l'autre alors que l'identifiant porte la page de
+ * depart.
+ */
+export function viewTemplateById(id: string): ViewTemplate | undefined {
+  return VIEW_TEMPLATES.find((template) => template.id === id);
+}
+
+/** Les templates d'une page, dans l'ordre du catalogue. */
+export function viewTemplatesFor(page: string): ViewTemplate[] {
+  const wanted = normalizePage(page);
+  return VIEW_TEMPLATES.filter(
+    (template) => template.page === wanted,
+  );
+}

package/layer/nuxt.config.ts

@@ -8,7 +8,16 @@
 // 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.
+import { fileURLToPath } from "node:url";
+
 export default defineNuxtConfig({
+  // Contrat avec l'app pour ce qui lui est propre (client API, bandeau,
+  // tables metier des vues et des alertes). Par defaut, les valeurs neutres
+  // du layer ; une app pointe `#oip-app` vers son dossier `app/oip` dans son
+  // propre nuxt.config, et sa valeur l'emporte.
+  alias: {
+    "#oip-app": fileURLToPath(new URL("./app/oip-defaults", import.meta.url)),
+  },
   future: {
     compatibilityVersion: 4,
   },
@@ -28,5 +37,14 @@ export default defineNuxtConfig({
     oipEsIndicesToken: "",
     /** Vrai en preproduction : interroge `staging_physical` quand il existe. */
     oipEsIndicesStaging: false,
+    /**
+     * Panneau Statistiques : cle personnelle PostHog (scope query:read), id
+     * numerique du projet et hote de l'API (pas celui d'ingestion). Vides :
+     * POSTHOG_STATS_KEY (ou POSTHOG_PERSONAL_API_KEY), POSTHOG_PROJECT_ID,
+     * POSTHOG_API_HOST.
+     */
+    oipPosthogKey: "",
+    oipPosthogProjectId: "",
+    oipPosthogHost: "",
   },
 });

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

@@ -146,7 +146,7 @@ export default defineEventHandler(async (event): Promise<ApiNote[]> => {
     // 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))
+      .filter((subject) => appUrls.includes(subject?.app?.prod_url ?? ""))
       .map((subject) => (subject!.relative_path ?? "").trim())
       .filter(Boolean);
     const sources = (row.linked_sources ?? [])

package/layer/server/api/oip/stats/users.get.ts

@@ -0,0 +1,80 @@
+import { defineEventHandler } from "h3";
+import { OIP_STATS_PATH, OIP_STATS_SINCE, oipStatsContext } from "../../../utils/oipPosthog";
+import { oipWorkspaceNames } from "../../../utils/oipWorkspaces";
+import { OIP_STATS_PERIODS, type OipStatsPeriod, type OipStatsUsers } from "../../../../app/types/stats";
+
+/**
+ * GET /api/oip/stats/users?period=7d&scope=app&offset=0&limit=10&path=&internal=0,
+ * servi par le layer OIP (panneau « Statistiques »).
+ *
+ * Le classement des utilisateurs par vues de page sur la periode, pour toute
+ * l'app (`scope=app`) ou l'ecran `path` (`scope=page`), une page a la fois :
+ * `hasMore` dit s'il reste des lignes apres celle-ci.
+ *
+ * Le workspace est le dernier `workspace_id` porte par les vues de la
+ * personne sur la periode, nomme par la Virtual Lab API.
+ *
+ * Perimetre, cle et droit : cf. oipStatsContext.
+ */
+
+const MAX_LIMIT = 100;
+const MAX_OFFSET = 5000;
+const CHUNK = 100;
+
+const prop = (name: string) => `nullIf(toString(person.properties.${name}), '')`;
+
+export default defineEventHandler(async (event): Promise<OipStatsUsers> => {
+  const { query, where, hogql } = await oipStatsContext(event);
+
+  const period = (OIP_STATS_PERIODS as readonly string[]).includes(String(query.period))
+    ? (query.period as OipStatsPeriod)
+    : "7d";
+  const onPage = query.scope === "page";
+  const offset = Math.min(MAX_OFFSET, Math.max(0, Math.floor(Number(query.offset) || 0)));
+  const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(Number(query.limit) || 10)));
+
+  // PostHog refuse OFFSET avec une cle personnelle : on lit depuis le haut du
+  // classement et on coupe ici. Une ligne de plus que demande : sa presence
+  // dit qu'il en reste. Lu par paquets de CHUNK lignes : les « Charger plus »
+  // suivants retombent sur la meme requete, servie par le cache.
+  const rowCap = Math.ceil((offset + limit + 1) / CHUNK) * CHUNK;
+  const ranking = hogql(`
+    SELECT
+      any(${prop("email")}),
+      any(${prop("firstName")}), any(${prop("lastName")}),
+      any(${prop("first_name")}), any(${prop("last_name")}), any(${prop("name")}),
+      argMaxIf(toString(properties.workspace_id), timestamp, notEmpty(coalesce(toString(properties.workspace_id), ''))),
+      count() AS pageviews,
+      uniq($session_id),
+      uniq(${OIP_STATS_PATH}),
+      max(timestamp) AS last_seen
+    FROM events
+    WHERE ${where} AND timestamp >= ${OIP_STATS_SINCE[period]}${onPage ? ` AND ${OIP_STATS_PATH} = {path}` : ""}
+    GROUP BY person_id
+    ORDER BY pageviews DESC, last_seen DESC
+    LIMIT ${rowCap}
+  `);
+  const [rows, workspaces] = await Promise.all([ranking, oipWorkspaceNames(event)]);
+
+  const text = (v: unknown) => (v == null ? "" : String(v).trim());
+  return {
+    hasMore: rows.length > offset + limit,
+    users: rows.slice(offset, offset + limit).map((r) => {
+      const [email, firstName, lastName, first_name, last_name, name, workspaceId, pageviews, sessions, pages, lastSeen] =
+        r;
+      const full =
+        [text(firstName), text(lastName)].filter(Boolean).join(" ") ||
+        [text(first_name), text(last_name)].filter(Boolean).join(" ") ||
+        text(name);
+      return {
+        email: text(email),
+        name: full,
+        workspace: workspaces.get(text(workspaceId)) ?? text(workspaceId),
+        pageviews: Number(pageviews) || 0,
+        sessions: Number(sessions) || 0,
+        pages: Number(pages) || 0,
+        lastSeen: text(lastSeen),
+      };
+    }),
+  };
+});

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

@@ -0,0 +1,88 @@
+import { defineEventHandler } from "h3";
+import { OIP_STATS_PATH, OIP_STATS_SINCE, oipStatsContext } from "../../utils/oipPosthog";
+import {
+  OIP_STATS_PERIODS,
+  type OipStats,
+  type OipStatsMetrics,
+  type OipStatsPeriod,
+} from "../../../app/types/stats";
+
+/**
+ * GET /api/oip/stats?path=/hubr/x&internal=0, servi par le layer OIP
+ * (panneau « Statistiques »).
+ *
+ * L'audience de l'ecran ouvert et de toute l'app, lue dans PostHog par une
+ * requete HogQL : personnes, sessions et vues de page, aujourd'hui et sur 7,
+ * 30 et 90 jours, plus les pages les plus vues.
+ *
+ * L'app est designee par l'hote de ses `prod_url` (`$host` des evenements),
+ * comme les notes la designent par son URL : le projet PostHog est commun a
+ * toute la flotte. Le plugin PostHog des apps ne capture ni localhost ni
+ * staging, il n'y a donc que la prod a compter.
+ *
+ * `internal=0` (defaut) ecarte les comptes @tekkare.com.
+ *
+ * Cle PostHog et perimetre commun : cf. oipStatsContext.
+ *
+ * Reservee aux superadmins, comme les metadonnees.
+ */
+
+const TOP_PAGES = 100;
+
+export default defineEventHandler(async (event): Promise<OipStats> => {
+  const { path, hosts, where, hogql } = await oipStatsContext(event);
+  const SINCE = OIP_STATS_SINCE;
+  const PATH = OIP_STATS_PATH;
+
+  const onPage = `${PATH} = {path}`;
+  const metrics = (scope: string, cond: string) =>
+    OIP_STATS_PERIODS.flatMap((p) => {
+      const c = `timestamp >= ${SINCE[p]}${cond ? ` AND ${cond}` : ""}`;
+      return [
+        `uniqIf(person_id, ${c}) AS ${scope}_users_${p.replace(/\W/g, "")}`,
+        `uniqIf($session_id, ${c}) AS ${scope}_sessions_${p.replace(/\W/g, "")}`,
+        `countIf(${c}) AS ${scope}_pageviews_${p.replace(/\W/g, "")}`,
+      ];
+    });
+
+  const [totals, top] = await Promise.all([
+    hogql(`SELECT ${[...metrics("page", onPage), ...metrics("app", "")].join(", ")} FROM events WHERE ${where}`),
+    hogql(`
+      SELECT ${PATH} AS page,
+        ${OIP_STATS_PERIODS.map((p) => `countIf(timestamp >= ${SINCE[p]})`).join(", ")},
+        ${OIP_STATS_PERIODS.map((p) => `uniqIf(person_id, timestamp >= ${SINCE[p]})`).join(", ")}
+      FROM events
+      WHERE ${where}
+      GROUP BY page
+      ORDER BY count() DESC
+      LIMIT ${TOP_PAGES}
+    `),
+  ]);
+
+  // Une ligne : page puis app, chaque periode portant users, sessions, pageviews.
+  const row = (totals[0] ?? []).map(Number);
+  const read = (offset: number) =>
+    Object.fromEntries(
+      OIP_STATS_PERIODS.map((p, i) => {
+        const [users = 0, sessions = 0, pageviews = 0] = row.slice(offset + i * 3, offset + i * 3 + 3);
+        return [p, { users, sessions, pageviews } satisfies OipStatsMetrics];
+      }),
+    ) as Record<OipStatsPeriod, OipStatsMetrics>;
+  const span = OIP_STATS_PERIODS.length * 3;
+
+  const n = OIP_STATS_PERIODS.length;
+  const byPeriod = (cells: unknown[]) =>
+    Object.fromEntries(OIP_STATS_PERIODS.map((p, i) => [p, Number(cells[i]) || 0])) as Record<OipStatsPeriod, number>;
+
+  return {
+    path,
+    hosts,
+    page: read(0),
+    app: read(span),
+    topPages: top.map((r) => ({
+      path: String(r[0] || "/"),
+      pageviews: byPeriod(r.slice(1, 1 + n)),
+      users: byPeriod(r.slice(1 + n, 1 + 2 * n)),
+    })),
+  };
+});

package/layer/server/utils/oipPosthog.ts

@@ -0,0 +1,134 @@
+import type { H3Event } from "h3";
+import type { OipStatsPeriod } from "../../app/types/stats";
+import { assertOipSuperAdmin, oipAppUrls } from "./oipGuards";
+
+// Socle des routes /api/oip/stats* (panneau « Statistiques ») : droit, cle
+// PostHog, perimetre de l'app et appel HogQL. Prefixe `oip` pour ne pas
+// masquer les helpers des apps (utils serveur auto-importes).
+
+// Debut de chaque periode, dans le fuseau du projet PostHog.
+export const OIP_STATS_SINCE: Record<OipStatsPeriod, string> = {
+  today: "toStartOfDay(now())",
+  "7d": "now() - INTERVAL 7 DAY",
+  "30d": "now() - INTERVAL 30 DAY",
+  "90d": "now() - INTERVAL 90 DAY",
+};
+
+// Chemin sans prefixe de langue ni barre finale : `/fr/hubr/x/` et `/hubr/x`
+// sont le meme ecran (meme peigne que `oipStatsNormalize`).
+const BARE = "replaceRegexpOne(replaceRegexpOne(toString(properties.$pathname), '^/(en|fr)(/|$)', '/'), '/+$', '')";
+export const OIP_STATS_PATH = `if(empty(${BARE}), '/', ${BARE})`;
+
+// PostHog plafonne son API de requetes (429 au-dela) : chaque ouverture du
+// panneau, chaque periode, chaque « Charger plus » en coutait une. Les memes
+// requetes sont donc servies de memoire cinq minutes ; les chiffres d'une
+// audience n'ont pas besoin d'etre plus frais.
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const CACHE_MAX = 500;
+const RETRY_MAX_S = 20;
+const cache = new Map<string, { at: number; rows: Promise<unknown[][]> }>();
+
+export function oipStatsNormalize(path: string) {
+  return (path.split("?")[0] || "").replace(/^\/(fr|en)(?=\/|$)/, "").replace(/\/+$/, "") || "/";
+}
+
+/**
+ * Verifie le droit et la configuration, puis rend le perimetre commun : les
+ * vues de page des 90 derniers jours sur les hotes de l'app (`prod_url`),
+ * sans les comptes @tekkare.com sauf `internal=1`, et `hogql` pour
+ * interroger PostHog. `path` (normalise) est passe en placeholder `{path}`.
+ *
+ * Cle personnelle PostHog (scope query:read) et id numerique du projet :
+ * `runtimeConfig.oipPosthogKey` / `oipPosthogProjectId`, sinon les env
+ * POSTHOG_STATS_KEY (ou POSTHOG_PERSONAL_API_KEY, le nom d'oip7) /
+ * POSTHOG_PROJECT_ID. La cle ne quitte jamais le serveur.
+ */
+export async function oipStatsContext(event: H3Event) {
+  await assertOipSuperAdmin(event);
+
+  const config = useRuntimeConfig();
+  const key =
+    (config.oipPosthogKey as string) || process.env.POSTHOG_STATS_KEY || process.env.POSTHOG_PERSONAL_API_KEY;
+  const projectId = (config.oipPosthogProjectId as string) || process.env.POSTHOG_PROJECT_ID;
+  if (!key || !projectId) {
+    throw createError({
+      status: 501,
+      message: "PostHog stats are not configured (POSTHOG_STATS_KEY, POSTHOG_PROJECT_ID)",
+    });
+  }
+  const apiHost = ((config.oipPosthogHost as string) || process.env.POSTHOG_API_HOST || "https://eu.posthog.com").replace(
+    /\/+$/,
+    "",
+  );
+
+  const query = getQuery(event);
+  const path = oipStatsNormalize(String(query.path || "/"));
+  const internal = query.internal === "1";
+  const hosts = [...new Set(oipAppUrls().map((url) => new URL(url).host))];
+
+  // Valeurs passees en placeholders HogQL : PostHog les substitue lui-meme.
+  const values: Record<string, string> = { path };
+  hosts.forEach((h, i) => (values[`host${i}`] = h));
+
+  const where = [
+    "event = '$pageview'",
+    `timestamp >= ${OIP_STATS_SINCE["90d"]}`,
+    `toString(properties.$host) IN (${hosts.map((_, i) => `{host${i}}`).join(", ")})`,
+    internal ? "" : "NOT endsWith(lower(coalesce(toString(person.properties.email), '')), '@tekkare.com')",
+  ]
+    .filter(Boolean)
+    .join(" AND ");
+
+  function hogql(sql: string): Promise<unknown[][]> {
+    // Seules les valeurs que la requete lit : le classement de toute l'app ne
+    // depend pas de l'ecran ouvert, et doit rester en cache d'une page a l'autre.
+    const used = Object.fromEntries(Object.entries(values).filter(([name]) => sql.includes(`{${name}}`)));
+    const cacheKey = JSON.stringify([projectId, sql, used]);
+    const hit = cache.get(cacheKey);
+    if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.rows;
+
+    if (cache.size >= CACHE_MAX) {
+      for (const [k, v] of cache) if (Date.now() - v.at >= CACHE_TTL_MS) cache.delete(k);
+      if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value!);
+    }
+    // La promesse elle-meme : deux appels simultanes partagent la requete.
+    const rows = run(sql, used);
+    cache.set(cacheKey, { at: Date.now(), rows });
+    rows.catch(() => cache.delete(cacheKey));
+    return rows;
+  }
+
+  async function run(sql: string, used: Record<string, string>, retried = false): Promise<unknown[][]> {
+    try {
+      const res = await $fetch<{ results?: unknown[][] }>(`${apiHost}/api/projects/${projectId}/query/`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${key}` },
+        body: { query: { kind: "HogQLQuery", query: sql, values: used } },
+      });
+      return res.results || [];
+    } catch (err: any) {
+      const status = err?.response?.status ?? err?.statusCode ?? "?";
+      const detail = err?.data?.detail || err?.data?.message || err?.message || String(err);
+      console.error(`[oip/stats] PostHog query failed (${status}): ${String(detail).slice(0, 300)}`);
+      if (status === 429) {
+        // « Request was throttled. Expected available in 1028 seconds. »
+        const wait = Number(/available in (\d+) second/.exec(String(detail))?.[1]);
+        // Limite a la minute (l'ouverture du panneau envoie trois requetes
+        // d'un coup) : on attend et on reessaie une fois. Le quota horaire,
+        // lui, se dit au lecteur.
+        if (!retried && wait && wait <= RETRY_MAX_S) {
+          await new Promise((resolve) => setTimeout(resolve, (wait + 1) * 1000));
+          return run(sql, used, true);
+        }
+        const minutes = wait ? Math.max(1, Math.ceil(wait / 60)) : 1;
+        throw createError({
+          status: 429,
+          message: `Quota de requêtes PostHog atteint, réessayer dans ${minutes} min`,
+        });
+      }
+      throw createError({ status: 502, message: `PostHog query failed (${status})` });
+    }
+  }
+
+  return { query, path, hosts, where, hogql };
+}

package/layer/server/utils/oipWorkspaces.ts

@@ -0,0 +1,51 @@
+import type { H3Event } from "h3";
+import { getOipAccessToken } from "./oipAuth";
+
+// Noms des workspaces de la Virtual Lab API, par id, pour le panneau
+// « Statistiques » : PostHog ne porte que `workspace_id` sur les evenements.
+// Prefixe `oip` pour ne pas masquer les helpers des apps.
+
+// La liste pagine a 100 et trie par date de creation : une seule page
+// cacherait les plus anciens.
+const PAGE_SIZE = 100;
+const MAX_PAGES = 20;
+const TTL_MS = 10 * 60 * 1000;
+
+let cache: { at: number; names: Map<string, string> } | null = null;
+
+/**
+ * Id vers nom de tous les workspaces, lus par `/superadmin/workspaces` avec le
+ * jeton de l'appelant (deja verifie superadmin), gardes dix minutes. En cas
+ * d'echec, une table vide : les statistiques restent lisibles sans les noms.
+ */
+export async function oipWorkspaceNames(event: H3Event): Promise<Map<string, string>> {
+  if (cache && Date.now() - cache.at < TTL_MS) return cache.names;
+
+  const token = await getOipAccessToken(event);
+  const apiUrl = (useRuntimeConfig().oipVirtualLabApiUrl as string) || process.env.VIRTUAL_LAB_API_URL;
+  if (!token || !apiUrl) return new Map();
+
+  type Page = { workspaces?: { id?: string; name?: string }[]; pagination?: { totalPages?: number } };
+  const listPage = (page: number) =>
+    $fetch<Page>(`${apiUrl}/superadmin/workspaces`, {
+      headers: { Authorization: `Bearer ${token}` },
+      query: { page, limit: PAGE_SIZE },
+    });
+
+  try {
+    const first = await listPage(1);
+    const pages = [first];
+    const total = Math.min(first.pagination?.totalPages ?? 1, MAX_PAGES);
+    if (total > 1) pages.push(...(await Promise.all(Array.from({ length: total - 1 }, (_, i) => listPage(i + 2)))));
+
+    const names = new Map<string, string>();
+    for (const page of pages) {
+      for (const w of page.workspaces ?? []) if (w.id && w.name) names.set(w.id, w.name);
+    }
+    cache = { at: Date.now(), names };
+    return names;
+  } catch (err: any) {
+    console.error(`[oip/stats] workspace list failed (${err?.response?.status ?? err?.statusCode ?? "?"})`);
+    return new Map();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.243",
+  "version": "0.1.245",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",
@@ -18,7 +18,8 @@
       "import": "./dist/runtime/utils/*.js"
     },
     "./layer": "./layer/nuxt.config.ts",
-    "./layer-utils/*": "./layer/app/utils/*.ts"
+    "./layer-utils/*": "./layer/app/utils/*.ts",
+    "./layer-composables/*": "./layer/app/composables/*.ts"
   },
   "main": "./dist/module.cjs",
   "module": "./dist/module.mjs",