@obsidiane/meridiane 0.0.6 → 0.0.10

package/tools/dev.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+import { deriveLibName } from './core/lib-name.js';
+import { normalizePreset, splitListArgs } from './core/paths.js';
+import { readOpenApiSpec } from './core/spec.js';
+import { createLogger } from './core/logger.js';
+import { generateBridgeWorkspace } from './core/generate.js';
+import { ensureStandaloneWorkspace, ensureToolchainInstalled } from './core/standalone.js';
+
+function run(cmd, args, { cwd, env } = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      stdio: 'inherit',
+      cwd: cwd ?? process.cwd(),
+      env: env ?? process.env,
+    });
+    child.on('exit', (code) => resolve(code ?? 0));
+  });
+}
+
+async function pathIsFile(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function readPackageJsonName(dir) {
+  try {
+    const raw = await fs.readFile(path.join(dir, 'package.json'), 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed?.name === 'string' ? parsed.name : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveDevAppRoot(startCwd) {
+  if (await pathIsFile(path.join(startCwd, 'package.json'))) return startCwd;
+  throw new Error('No package.json found. Run `meridiane dev` from your Angular app root.');
+}
+
+async function isMeridianeSandboxApp(appRoot) {
+  const name = await readPackageJsonName(appRoot);
+  return name === '@obsidiane/meridiane-sandbox';
+}
+
+async function resolveSandboxAppRoot(startCwd) {
+  // Allow running from apps/sandbox directly
+  if (await isMeridianeSandboxApp(startCwd)) return startCwd;
+
+  // Allow running from this repo root (monorepo) and target apps/sandbox
+  const sandboxApp = path.join(startCwd, 'apps', 'sandbox');
+  if (await pathIsFile(path.join(sandboxApp, 'package.json')) && (await isMeridianeSandboxApp(sandboxApp))) {
+    return sandboxApp;
+  }
+
+  throw new Error('Missing <packageName>. Run from the sandbox app (`apps/sandbox`) or provide a package name.');
+}
+
+async function findLatestTgz(distDir) {
+  const entries = await fs.readdir(distDir, { withFileTypes: true }).catch(() => []);
+  const tgzFiles = [];
+  for (const e of entries) {
+    if (!e.isFile()) continue;
+    if (!e.name.endsWith('.tgz')) continue;
+    const full = path.join(distDir, e.name);
+    const st = await fs.stat(full);
+    tgzFiles.push({ full, mtimeMs: st.mtimeMs });
+  }
+  tgzFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return tgzFiles[0]?.full;
+}
+
+function splitPackageName(packageName) {
+  const s = String(packageName || '').trim();
+  if (!s) throw new Error('Missing packageName');
+  if (s.startsWith('@')) {
+    const [scope, name] = s.split('/');
+    if (!scope || !name) throw new Error(`Invalid packageName: ${packageName}`);
+    return { scope, name };
+  }
+  return { scope: undefined, name: s };
+}
+
+async function resolveNodeModulesRoot(startDir) {
+  let cur = startDir;
+  for (;;) {
+    const candidate = path.join(cur, 'node_modules');
+    try {
+      const st = await fs.stat(candidate);
+      if (st.isDirectory()) return candidate;
+    } catch {
+      // ignore
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+
+  const nm = path.join(startDir, 'node_modules');
+  await fs.mkdir(nm, { recursive: true });
+  return nm;
+}
+
+async function installPackageFromDist({ packageName, distDir, appRoot, log }) {
+  const nmRoot = await resolveNodeModulesRoot(appRoot);
+  const { scope, name } = splitPackageName(packageName);
+  const pkgDir = scope ? path.join(nmRoot, scope, name) : path.join(nmRoot, name);
+
+  log?.step?.(`installation locale dans node_modules (${scope ? `${scope}/${name}` : name})`);
+
+  await fs.rm(pkgDir, { recursive: true, force: true });
+  await fs.mkdir(path.dirname(pkgDir), { recursive: true });
+
+  await fs.cp(distDir, pkgDir, {
+    recursive: true,
+    filter: (src) => !src.endsWith('.tgz'),
+  });
+
+  return pkgDir;
+}
+
+export async function runDev(packageName, opts) {
+  const startCwd = process.cwd();
+  const debug = !!opts.debug;
+  const log = createLogger({ debug });
+
+  const useSandboxDefaults = packageName === undefined;
+  const appRoot = useSandboxDefaults ? await resolveSandboxAppRoot(startCwd) : await resolveDevAppRoot(startCwd);
+
+  const effectivePackageName = packageName ?? '@obsidiane/bridge-sandbox';
+  const libName = deriveLibName(effectivePackageName);
+
+  const noModels = opts.models === false;
+  const preset = normalizePreset(useSandboxDefaults ? (opts.preset ?? 'native') : opts.preset);
+  const include = splitListArgs(opts.include);
+  const exclude = splitListArgs(opts.exclude);
+
+  const version = '0.0.0-dev';
+  const requiredMode = 'all-optional';
+  const specSource = useSandboxDefaults ? (opts.spec ?? 'http://localhost:8000/api/docs.json') : opts.spec;
+
+  log.title('dev — build standalone + install local');
+  log.info(`app: ${appRoot}`);
+  log.info(`package: ${effectivePackageName}@${version}`);
+  log.info(`lib: ${libName}`);
+  if (useSandboxDefaults) log.info('defaults sandbox appliqués');
+  if (noModels) log.info('models: désactivés (--no-models)');
+  else log.info(`spec: ${specSource} | preset: ${preset}`);
+
+  const { workspaceRoot, distRoot, npmCacheDir, requireFromWs } = await ensureStandaloneWorkspace({ repoRoot: appRoot, log });
+  log.info(`workspace: ${workspaceRoot}`);
+
+  let spec;
+  if (!noModels) {
+    log.step('lecture de la spec OpenAPI');
+    spec = await readOpenApiSpec(specSource);
+    log.success('spec chargée');
+  }
+
+  await ensureToolchainInstalled({ workspaceRoot, requireFromWs, npmCacheDir, log });
+
+  await generateBridgeWorkspace({
+    cwd: workspaceRoot,
+    libName,
+    packageName: effectivePackageName,
+    version,
+    noModels,
+    spec,
+    requiredMode,
+    preset,
+    include,
+    exclude,
+    debug,
+    log,
+    distRoot,
+  });
+
+  const ngPackageJsonPath = path.join(workspaceRoot, 'projects', libName, 'ng-package.json');
+  const tsconfigDevPath = path.join(workspaceRoot, 'projects', libName, 'tsconfig.lib.json');
+
+  log.step('ng-packagr');
+  const ngPackagrPath = requireFromWs.resolve('ng-packagr/src/cli/main.js');
+  const packagrCode = await run(process.execPath, [ngPackagrPath, '-p', ngPackageJsonPath, '-c', tsconfigDevPath], {
+    cwd: workspaceRoot,
+  });
+  if (packagrCode !== 0) process.exit(packagrCode);
+
+  const distDir = path.join(distRoot, libName);
+  log.step(`npm pack (${path.relative(appRoot, distDir)})`);
+  const packCode = await run('npm', ['pack'], {
+    cwd: distDir,
+    env: {
+      ...process.env,
+      npm_config_cache: npmCacheDir,
+      npm_config_update_notifier: 'false',
+      npm_config_fund: 'false',
+      npm_config_audit: 'false',
+    },
+  });
+  if (packCode !== 0) process.exit(packCode);
+
+  await findLatestTgz(distDir); // keep producing the tgz in dist for inspection/use
+  await installPackageFromDist({ packageName: effectivePackageName, distDir, appRoot, log });
+
+  log.success('bridge installé (node_modules) ✅');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  throw new Error('This module is not meant to be executed directly.');
+}

package/tools/generator/models/handlebars.js

@@ -2,13 +2,19 @@ import fs from 'node:fs/promises';
 import * as path from 'node:path';
 import Handlebars from 'handlebars';
 
+const templateCache = new Map();
+
 /**
  * Rend un template Handlebars avec un contexte et écrit le fichier.
  * @param {{ templatePath: string, outPath: string, ctx: any }} params
  */
 export async function renderTemplateToFile({templatePath, outPath, ctx}) {
-  const tplSrc = await fs.readFile(templatePath, 'utf8');
-  const tpl = Handlebars.compile(tplSrc, {noEscape: true});
+  let tpl = templateCache.get(templatePath);
+  if (!tpl) {
+    const tplSrc = await fs.readFile(templatePath, 'utf8');
+    tpl = Handlebars.compile(tplSrc, {noEscape: true});
+    templateCache.set(templatePath, tpl);
+  }
   const out = tpl(ctx);
   await fs.mkdir(path.dirname(outPath), {recursive: true});
   await fs.writeFile(outPath, out, 'utf8');

package/tools/generator/models/naming.js

@@ -1,20 +1,26 @@
 /**
- * Convertit un nom de schéma OpenAPI en un nom lisible (sans artefacts jsonld/jsonapi)
- * et intégrant les groupes (ex: Identity.jsonld-user.read -> Identity user read)
+ * Construit un label "tokenisé" (sans `.` ni `-`) à partir d'un nom de schéma OpenAPI.
+ * Le label est ensuite passé à `sanitizeTypeName()` pour produire un identifiant TS stable.
+ *
  * @param {string} original
+ * @param {{ preset: 'all'|'native' }} cfg
  */
-export function friendlyName(original) {
-  const m = original.match(/^(.*?)(?:\.(?:jsonld|jsonapi))?-(.+)$/i);
-  if (m) {
-    const base = m[1];
-    const baseSimple = base.split('.').pop();
-    const groupTokens = m[2].split('.');
-    if (groupTokens.length && groupTokens[0].toLowerCase() === String(baseSimple).toLowerCase()) {
-      groupTokens.shift();
-    }
-    const group = groupTokens.join(' ');
-    return group ? `${base} ${group}` : base;
+export function schemaLabel(original, cfg) {
+  const preset = cfg?.preset ?? 'all';
+  if (preset === 'native') {
+    // En native, on vise un nom "entity-like" : on ignore le groupe (après `-`) si présent.
+    // Les variantes .jsonld/.jsonapi/jsonMergePatch sont censées être filtrées par le preset.
+    return String(original).split('-')[0];
   }
-  return original.replace(/\.(jsonld|jsonapi)$/ig, '');
-}
 
+  // En all, on encode tout : `.` et `-` deviennent des séparateurs de tokens.
+  const rawTokens = String(original).split(/[.-]/g).filter(Boolean);
+  const tokens = rawTokens.map((t) => {
+    const lower = t.toLowerCase();
+    if (lower === 'jsonld') return 'Jsonld';
+    if (lower === 'jsonapi') return 'Jsonapi';
+    if (lower === 'jsonmergepatch' || t === 'jsonMergePatch') return 'JsonMergePatch';
+    return t;
+  });
+  return tokens.join(' ');
+}

package/tools/generator/models/openapi-to-models.js

@@ -1,46 +1,52 @@
 import { sanitizeTypeName, quoteKeyIfNeeded } from './utils.js';
-import { filterSchemaNames, mergeAllOf, isObject } from './schema-utils.js';
-import { friendlyName } from './naming.js';
+import { filterSchemaNames, applySchemaNameFilters, mergeAllOf, isObject, schemaNameFromRef } from './schema-utils.js';
+import { schemaLabel } from './naming.js';
 import { tsTypeOf, withNullable } from './type-resolver.js';
 
+/**
+ * @typedef {{
+ *   requiredMode?: 'all-optional'|'spec',
+ *   preset?: 'all'|'native',
+ *   includeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ *   excludeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ * }} BuildOptions
+ */
+
 /**
  * Construit une map originalName -> sanitizedName, en assurant l’unicité
  * @param {string[]} schemaNames
  */
-function buildNameMap(schemaNames) {
-  const parse = (original) => {
-    const m = original.match(/^(.*?)(?:\.(?:jsonld|jsonapi))?-(.+)$/i);
-    return m ? { base: m[1], group: m[2] } : { base: original, group: null };
-  };
-
-  const parsed = schemaNames.map((n) => ({ name: n, ...parse(n) }));
-  const roots = parsed.filter((p) => !p.group);
-  const grouped = parsed.filter((p) => !!p.group);
-
-  // Root sanitized names (to avoid collisions when dropping group)
-  const rootSanitized = new Set(roots.map((p) => sanitizeTypeName(p.base, new Set())));
-
-  // Count base candidates among grouped to see if unique
-  const baseCount = new Map();
-  for (const p of grouped) {
-    const cand = sanitizeTypeName(p.base, new Set());
-    baseCount.set(cand, (baseCount.get(cand) || 0) + 1);
-  }
+function normalizeNativeBase(original) {
+  return String(original)
+    .replace(/\.jsonld\b/ig, '')
+    .replace(/\.jsonapi\b/ig, '')
+    .replace(/\.jsonmergepatch\b/ig, '')
+    .split('-')[0];
+}
 
-  // Build final map with uniqueness
+function buildNameMap(schemaNames, schemas, preset) {
+  // Build final map with uniqueness (deterministic order)
   const used = new Set();
   const nameMap = new Map();
-  for (const p of parsed) {
-    let label;
-    if (p.group) {
-      const cand = sanitizeTypeName(p.base, new Set());
-      const isUniqueBase = (baseCount.get(cand) === 1) && !rootSanitized.has(cand);
-      label = isUniqueBase ? p.base : friendlyName(p.name);
-    } else {
-      label = friendlyName(p.name);
+  for (const original of schemaNames) {
+    const label = schemaLabel(original, {preset});
+    nameMap.set(original, sanitizeTypeName(label, used));
+  }
+
+  // In native mode, alias excluded variants to the selected base type
+  // so `$ref` doesn't leak "User-user.write" etc into generated types.
+  if (preset === 'native') {
+    const baseToSanitized = new Map();
+    for (const original of schemaNames) {
+      baseToSanitized.set(normalizeNativeBase(original), nameMap.get(original));
+    }
+    for (const original of Object.keys(schemas)) {
+      const base = normalizeNativeBase(original);
+      const sanitized = baseToSanitized.get(base);
+      if (sanitized) nameMap.set(original, sanitized);
     }
-    nameMap.set(p.name, sanitizeTypeName(label, used));
   }
+
   return nameMap;
 }
 
@@ -53,8 +59,9 @@ function buildNameMap(schemaNames) {
 export function buildModelsFromOpenAPI(spec, options) {
   const opts = { requiredMode: 'all-optional', ...(options || {}) };
   const schemas = spec?.components?.schemas || {};
-  const schemaNames = filterSchemaNames(schemas, opts);
-  const nameMap = buildNameMap(schemaNames);
+  const schemaNames = applySchemaNameFilters(filterSchemaNames(schemas, opts), opts);
+  const preset = opts.preset ?? 'all';
+  const nameMap = buildNameMap(schemaNames, schemas, preset);
   const allSanitizedNames = new Set([...nameMap.values()]);
 
   /** @type {ModelDefinition[]} */
@@ -62,19 +69,49 @@ export function buildModelsFromOpenAPI(spec, options) {
 
   for (const originalName of schemaNames) {
     const raw = schemas[originalName];
+    const sanitized = nameMap.get(originalName);
+    if (!sanitized) continue;
+
+    /** @type {string[]} */
+    const extendsTypes = [];
+
     let effective = raw;
     if (raw?.allOf) {
-      const merged = mergeAllOf(raw.allOf, opts);
-      if (merged) effective = merged;
+      const merged = mergeAllOf(raw.allOf);
+      if (merged) {
+        effective = merged;
+      } else {
+        // Non-flattenable allOf (refs, mixed forms): keep inline object props and model refs as extends.
+        const props = {};
+        const required = new Set();
+        const ext = new Set();
+
+        for (const part of raw.allOf) {
+          if (part?.$ref) {
+            const orig = schemaNameFromRef(part.$ref);
+            const refName = orig ? nameMap.get(orig) : undefined;
+            if (refName && refName !== sanitized && allSanitizedNames.has(refName)) ext.add(refName);
+            continue;
+          }
+          const isObj = part?.type === 'object' || isObject(part?.properties);
+          if (!isObj) continue;
+          Object.assign(props, part.properties || {});
+          for (const r of part.required || []) required.add(r);
+        }
+
+        extendsTypes.push(...[...ext].sort((a, b) => a.localeCompare(b)));
+        effective = { type: 'object', properties: props, required: [...required] };
+      }
     }
 
-    const isObjectLike = effective?.type === 'object' || isObject(effective?.properties);
+    const isObjectLike = effective?.type === 'object' || isObject(effective?.properties) || extendsTypes.length > 0;
     if (!isObjectLike) continue;
 
-    const sanitized = nameMap.get(originalName);
     const required = new Set(effective.required || []);
     const deps = new Set();
 
+    for (const e of extendsTypes) deps.add(e);
+
     const props = Object.entries(effective.properties || {}).map(([propName, prop]) => {
       const baseType = tsTypeOf(prop, deps, nameMap);
       const type = withNullable(baseType, prop);
@@ -91,7 +128,7 @@ export function buildModelsFromOpenAPI(spec, options) {
       .filter((n) => allSanitizedNames.has(n))
       .sort((a, b) => a.localeCompare(b));
 
-    models.push({name: sanitized, props, imports});
+    models.push({name: sanitized, props, imports, extendsTypes});
   }
 
   return {models};

package/tools/generator/models/schema-utils.js

@@ -1,16 +1,5 @@
-/** Hydra base schemas to ignore in merges and filtering */
-const DEFAULT_HYDRA_BASE_RE = /^Hydra(?:Item|Collection)BaseSchema$/;
-
-/**
- * Récupère la RegExp Hydra à partir d'une config optionnelle.
- * @param {{ hydraBaseRegex?: RegExp|string }} [cfg]
- */
-function hydraRe(cfg) {
-  const r = cfg?.hydraBaseRegex;
-  if (!r) return DEFAULT_HYDRA_BASE_RE;
-  if (r instanceof RegExp) return r;
-  try { return new RegExp(r); } catch { return DEFAULT_HYDRA_BASE_RE; }
-}
+/** Hydra base schemas to ignore in safe `allOf` merges */
+const HYDRA_BASE_RE = /^Hydra(?:Item|Collection)BaseSchema$/;
 
 /**
  * Détermine si une valeur est un objet simple (non tableau)
@@ -37,12 +26,12 @@ export function schemaNameFromRef($ref) {
  * @param {any[]} schemas
  * @returns {any|null}
  */
-export function mergeAllOf(schemas, cfg) {
+export function mergeAllOf(schemas) {
   const out = {type: 'object', properties: {}, required: []};
   for (const s of schemas) {
     if (s.$ref) {
       const ref = schemaNameFromRef(s.$ref);
-      if (hydraRe(cfg).test(ref)) {
+      if (HYDRA_BASE_RE.test(ref)) {
         continue;
       }
       return null;
@@ -59,67 +48,96 @@ export function mergeAllOf(schemas, cfg) {
 }
 
 /**
- * Filtre et déduplique les noms de schémas à générer.
- * Préférence entre variantes: jsonld > none > jsonapi.
- * - Exclut HydraItem/Collection base schemas
- * - Garde les noms groupés (avec `-`) en choisissant la meilleure variante
- * - Garde les racines sans point et sans suffixe jsonld/jsonapi
+ * Liste les noms de schémas dans `components.schemas`.
+ * La sélection/filtres est gérée par `applySchemaNameFilters`.
  * @param {Record<string, any>} schemas
  * @returns {string[]}
  */
 export function filterSchemaNames(schemas, cfg) {
-  const prefer = (cfg?.preferFlavor === 'jsonapi') ? ['jsonapi','none','jsonld']
-               : (cfg?.preferFlavor === 'none') ? ['none','jsonld','jsonapi']
-               : ['jsonld','none','jsonapi']; // default jsonld
-  const flavorOf = (name) => /\.jsonld\b/i.test(name) ? 'jsonld' : /\.jsonapi\b/i.test(name) ? 'jsonapi' : 'none';
-  const rank = (name) => 3 - prefer.indexOf(flavorOf(name));
+  return Object.keys(schemas).sort((a, b) => a.localeCompare(b));
+}
+
+/**
+ * @param {unknown} rule
+ * @returns {rule is ((name: string) => boolean)}
+ */
+function isRuleFn(rule) {
+  return typeof rule === 'function';
+}
+
+/**
+ * @param {string} name
+ * @param {RegExp|string|((name: string) => boolean)} rule
+ */
+function matchesRule(name, rule) {
+  if (rule instanceof RegExp) return rule.test(name);
+  if (isRuleFn(rule)) return !!rule(name);
+  if (typeof rule === 'string' && rule.length) return name.includes(rule);
+  return false;
+}
 
-  const roots = [];
-  const grouped = new Map();
-  const variantsNoGroup = new Map(); // base -> best variant (no '-')
+/**
+ * Applique un preset de génération et/ou des règles include/exclude.
+ *
+ * - `preset: "all"`: ne filtre rien (comportement par défaut)
+ * - `preset: "native"`: retire les schémas "techniques" (Hydra*, jsonMergePatch…)
+ *
+ * Les règles `includeSchemaNames` / `excludeSchemaNames` s'appliquent sur les noms
+ * de schémas OpenAPI (ex: "User-user.read", "Conversation.jsonMergePatch", …).
+ *
+ * @param {string[]} schemaNames
+ * @param {{
+ *   preset?: 'all'|'native',
+ *   includeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ *   excludeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ * }} [cfg]
+ */
+export function applySchemaNameFilters(schemaNames, cfg) {
+  const preset = cfg?.preset ?? 'all';
 
-  for (const n of Object.keys(schemas)) {
-    if (hydraRe(cfg).test(n)) continue;
+  /** @type {Array<RegExp|string|((name: string) => boolean)>} */
+  const include = Array.isArray(cfg?.includeSchemaNames) ? cfg.includeSchemaNames : [];
+  /** @type {Array<RegExp|string|((name: string) => boolean)>} */
+  const exclude = Array.isArray(cfg?.excludeSchemaNames) ? [...cfg.excludeSchemaNames] : [];
 
-    const hasGroup = n.includes('-');
-    const hasDot = n.includes('.');
-    const isJsonFlavor = /\.jsonld\b|\.jsonapi\b/i.test(n);
+  // 1) include/exclude user filters (always applied first)
+  const hasInclude = include.length > 0;
+  let out = schemaNames.filter((name) => {
+    if (hasInclude && !include.some((r) => matchesRule(name, r))) return false;
+    if (exclude.some((r) => matchesRule(name, r))) return false;
+    return true;
+  });
 
-    if (!hasGroup) {
-      // Cas 1: racine simple (pas de point, pas de variante jsonld/jsonapi)
-      if (!hasDot && !isJsonFlavor) {
-        roots.push(n);
-        continue;
-      }
-      // Cas 2: variante jsonld/jsonapi sans groupe (ex: Workflow.WorkflowInput.jsonld ou Foo.jsonld)
-      if (isJsonFlavor) {
-        const base = n.replace(/\.(jsonld|jsonapi)\b/i, '');
-        // Si une base "pure" existe dans la spec, on préfère l’ignorer pour éviter les doublons
-        if (Object.prototype.hasOwnProperty.call(schemas, base)) {
-          continue;
-        }
-        const curr = variantsNoGroup.get(base);
-        if (!curr || rank(n) > rank(curr)) variantsNoGroup.set(base, n);
+  // 2) preset filters
+  if (preset === 'native') {
+    out = out
+      .filter((n) => !/^Hydra/i.test(n))
+      .filter((n) => !/jsonMergePatch/i.test(n))
+      .filter((n) => !/\.jsonld\b/i.test(n))
+      .filter((n) => !/\.jsonapi\b/i.test(n));
+
+    // 3) collapse group variants: keep one schema per base (before `-`)
+    const score = (name) => {
+      if (!name.includes('-')) return 100;
+      const group = name.split('-').slice(1).join('-');
+      if (/(^|[.\-])read($|[.\-])/i.test(group)) return 50;
+      return 0;
+    };
+    const byBase = new Map();
+    for (const name of out) {
+      const base = name.split('-')[0];
+      const prev = byBase.get(base);
+      if (!prev) {
+        byBase.set(base, name);
         continue;
       }
-      // Cas 3: nom avec point mais sans suffixe jsonld/jsonapi et sans group — on le considère tel quel
-      variantsNoGroup.set(n, n);
-      continue;
-    }
-
-    const m = n.match(/^(.*?)(?:\.(?:jsonld|jsonapi))?-(.+)$/i);
-    if (!m) {
-      const curr = grouped.get(n);
-      if (!curr || rank(n) > rank(curr)) grouped.set(n, n);
-      continue;
+      const a = prev, b = name;
+      const sa = score(a), sb = score(b);
+      if (sb > sa) byBase.set(base, b);
+      else if (sb === sa && b.localeCompare(a) < 0) byBase.set(base, b);
     }
-    const base = m[1];
-    const group = m[2];
-    const key = `${base}|${group}`;
-    const curr = grouped.get(key);
-    if (!curr || rank(n) > rank(curr)) grouped.set(key, n);
+    out = [...byBase.values()].sort((a, b) => a.localeCompare(b));
   }
-  // Ajoute les variantes sans groupe sélectionnées
-  const noGroupSelected = [...variantsNoGroup.values()];
-  return [...roots, ...[...grouped.values()], ...noGroupSelected].sort((a, b) => a.localeCompare(b));
+
+  return out;
 }

package/tools/generator/models/templates/model.hbs

@@ -1,9 +1,9 @@
-import { Item } from '{{itemImportPath}}';
+import type { Item } from '../lib/ports/resource-repository.port';
 {{#each imports}}
-import { {{this}} } from './{{this}}';
+import type { {{this}} } from './{{this}}';
 {{/each}}
 
-export interface {{name}} extends Item {
+export interface {{name}} extends Item{{#each extendsTypes}}, {{this}}{{/each}} {
 {{#each props}}
   {{{tsKey}}}{{#if optional}}?{{/if}}: {{type}};
 {{/each}}

package/tools/generator/models/utils.js

@@ -33,8 +33,7 @@ export function pascalCase(tokens) {
  * @param {Set<string>} used
  */
 export function sanitizeTypeName(original, used) {
-  const base = original.includes('.') ? original.split('.').pop() : original;
-  const tokens = base.split(/[^A-Za-z0-9]+/);
+  const tokens = String(original).split(/[^A-Za-z0-9]+/);
   let name = pascalCase(tokens) || 'Model';
   if (/^[0-9]/.test(name)) name = '_' + name;
   if (RESERVED.has(name)) name = name + 'Model';