@obsidiane/meridiane 2.0.10 → 2.0.11

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

@@ -1,240 +0,0 @@
-import { sanitizeTypeName, quoteKeyIfNeeded } from './utils.js';
-import { mergeAllOf, isObject, schemaNameFromRef } from './schema-utils.js';
-import { tsTypeOf, withNullable } from './type-resolver.js';
-import { canonicalizeMediaType, collectUsedSchemasForMediaType, expandWithSchemaDependencies } from './oas-contract.js';
-import { baseTsNameFromBasePath, formatSuffixToken, groupTsNameFromGroupPath, parseOpenApiSchemaName } from './oas-schema-name.js';
-
-/**
- * @typedef {{
- *   requiredMode?: 'all'|'spec',
- *   formats?: string[],
- *   includeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
- *   excludeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
- * }} BuildOptions
- */
-
-/**
- * @typedef {{
- *   name: string,
- *   tsKey: string,
- *   type: string,
- *   optional: boolean,
- * }} ModelProp
- */
-
-/**
- * @typedef {{
- *   name: string,
- *   props: ModelProp[],
- *   imports: string[],
- *   extendsTypes: string[],
- *   extendsItem?: boolean,
- * }} ModelDefinition
- */
-
-function ensureNullable(ts) {
-  return /\|\s*null\b/.test(ts) ? ts : `${ts} | null`;
-}
-
-function normalizeRequiredMode(value) {
-  const v = String(value ?? '').trim().toLowerCase();
-  if (!v) return 'all';
-  if (v === 'spec') return 'spec';
-  if (v === 'all') return 'all';
-  return 'all';
-}
-
-/**
- * Construit les définitions de modèles à partir d’une spec OpenAPI (components.schemas)
- * @param {any} spec
- * @param {BuildOptions} [options]
- * @returns {{ models: ModelDefinition[] }}
- */
-export function buildModelsFromOpenAPI(spec, options) {
-  const opts = { requiredMode: 'all', ...(options || {}) };
-  const schemas = spec?.components?.schemas || {};
-  const formatsOpt = Array.isArray(opts.formats) ? opts.formats : [];
-  const formats = formatsOpt.length > 0 ? formatsOpt : ['application/ld+json'];
-  const requiredMode = normalizeRequiredMode(opts.requiredMode);
-
-  /** @type {ModelDefinition[]} */
-  const models = [];
-
-  // Contract-driven (formats): keep only schemas used by selected media types in real endpoints.
-  const normalizedFormats = [];
-  for (const f of formats) {
-    const canon = canonicalizeMediaType(f);
-    if (!canon) continue;
-    if (!normalizedFormats.includes(canon)) normalizedFormats.push(canon);
-  }
-  if (normalizedFormats.length === 0) normalizedFormats.push('application/ld+json');
-
-  /** @type {Map<string, Set<string>>} */
-  const usedByFormat = new Map(); // formatLower -> Set<schemaName>
-
-  for (const fmt of normalizedFormats) {
-    usedByFormat.set(fmt, collectUsedSchemasForMediaType(spec, { mediaType: fmt }));
-  }
-
-  /** @type {Map<string, Set<string>>} */
-  const schemaToFormats = new Map();
-  for (const [fmt, names] of usedByFormat.entries()) {
-    for (const name of names) {
-      if (!name) continue;
-      const set = schemaToFormats.get(name) || new Set();
-      set.add(fmt);
-      schemaToFormats.set(name, set);
-    }
-  }
-
-  const include = Array.isArray(opts.includeSchemaNames) ? opts.includeSchemaNames : [];
-  const exclude = Array.isArray(opts.excludeSchemaNames) ? opts.excludeSchemaNames : [];
-  const matches = (val, rule) => {
-    if (rule instanceof RegExp) return rule.test(val);
-    if (typeof rule === 'function') return !!rule(val);
-    if (typeof rule === 'string' && rule.length) return val.includes(rule);
-    return false;
-  };
-
-  const allUsed = [...schemaToFormats.keys()]
-    .filter(Boolean)
-    .filter((n) => !/^Hydra/i.test(n))
-    .sort((a, b) => a.localeCompare(b))
-    .filter((originalName) => {
-      const parsed = parseOpenApiSchemaName(originalName);
-      const canonical = parsed.groupPath ? `${parsed.basePath}-${parsed.groupPath}` : parsed.basePath;
-      const fulls = [originalName, canonical];
-
-      const hasInclude = include.length > 0;
-      const included = !hasInclude || include.some((r) => fulls.some((v) => matches(v, r)));
-      const excluded = exclude.some((r) => fulls.some((v) => matches(v, r)));
-      return included && !excluded;
-    });
-
-  // Ensure filters never break compilation: always keep transitive deps of selected schemas.
-  const candidatesSet = include.length > 0 || exclude.length > 0 ? expandWithSchemaDependencies(allUsed, schemas) : new Set(allUsed);
-
-  const candidates = [...candidatesSet]
-    .filter((n) => !!n)
-    .filter((n) => !/^Hydra/i.test(n))
-    .sort((a, b) => a.localeCompare(b));
-
-  // Assign a preferred format to each schema (used for naming + JSON-LD behavior).
-  const formatIndex = new Map(normalizedFormats.map((f, i) => [f, i]));
-  const schemaEntries = candidates.map((schemaName) => {
-    const fmts = schemaToFormats.get(schemaName) || new Set();
-    const best = [...fmts].sort((a, b) => (formatIndex.get(a) ?? 999) - (formatIndex.get(b) ?? 999))[0] || normalizedFormats[0];
-    return { schemaName, preferredFormat: best, preferredFormatIndex: formatIndex.get(best) ?? 0 };
-  });
-  const preferredFormatBySchema = new Map(schemaEntries.map((e) => [e.schemaName, e.preferredFormat]));
-
-  // Compute desired TS names (format-agnostic), then disambiguate collisions by preferred format.
-  const byDesired = new Map(); // desired -> entries[]
-  for (const e of schemaEntries) {
-    const parsed = parseOpenApiSchemaName(e.schemaName);
-    if (parsed.isMergePatch) continue; // never generate patch models
-    const baseTs = baseTsNameFromBasePath(parsed.basePath);
-    const groupTs = groupTsNameFromGroupPath(parsed.groupPath);
-    const desired = `${baseTs}${groupTs}` || 'Model';
-    const list = byDesired.get(desired) || [];
-    list.push({ ...e, desired });
-    byDesired.set(desired, list);
-  }
-
-  // Assign unique TS names and build schemaName -> tsName map.
-  const usedTsNames = new Set();
-  const nameMap = new Map();
-  for (const [desired, list] of [...byDesired.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-    list.sort((a, b) => {
-      const da = a.preferredFormatIndex - b.preferredFormatIndex;
-      if (da !== 0) return da;
-      return a.schemaName.localeCompare(b.schemaName);
-    });
-
-    for (let i = 0; i < list.length; i++) {
-      const entry = list[i];
-      const withFmt = i === 0 ? desired : `${desired}${formatSuffixToken(entry.preferredFormat)}`;
-      const tsName = sanitizeTypeName(withFmt, usedTsNames);
-      nameMap.set(entry.schemaName, tsName);
-    }
-  }
-  const allSanitizedNames = new Set([...nameMap.values()]);
-
-  for (const schemaName of candidates) {
-    const sanitized = nameMap.get(schemaName);
-    if (!sanitized) continue;
-
-    const raw = schemas[schemaName];
-    if (!raw) continue;
-
-    const preferredFormat = preferredFormatBySchema.get(schemaName) ?? normalizedFormats[0];
-    const isJsonLd = canonicalizeMediaType(preferredFormat) === 'application/ld+json';
-    const forceNullable = requiredMode !== 'spec';
-
-    /** @type {string[]} */
-    const extendsTypes = [];
-    const deps = new Set();
-
-    let effective = raw;
-    if (raw?.allOf) {
-      const merged = mergeAllOf(raw.allOf);
-      if (merged) {
-        effective = merged;
-      } else {
-        // Non-flattenable allOf: keep inline object props + other 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);
-            if (!orig) continue;
-            if (/^Hydra/i.test(orig)) continue;
-            const refName = orig ? nameMap.get(orig) || 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) || extendsTypes.length > 0;
-    if (!isObjectLike) continue;
-
-    for (const e of extendsTypes) deps.add(e);
-
-    const required = new Set(effective.required || []);
-    const props = Object.entries(effective.properties || {})
-      .filter(([propName]) => {
-        if (!isJsonLd) return true;
-        return propName !== '@id' && propName !== '@type' && propName !== '@context';
-      })
-      .map(([propName, prop]) => {
-        const baseType = tsTypeOf(prop, deps, nameMap, { requiredMode });
-        const type = forceNullable ? ensureNullable(baseType) : withNullable(baseType, prop);
-        return {
-          name: propName,
-          tsKey: quoteKeyIfNeeded(propName),
-          type,
-          optional: requiredMode === 'spec' ? !required.has(propName) : true,
-        };
-      });
-
-    const imports = [...deps]
-      .filter((n) => n !== sanitized)
-      .filter((n) => allSanitizedNames.has(n))
-      .sort((a, b) => a.localeCompare(b));
-
-    models.push({ name: sanitized, props, imports, extendsTypes, extendsItem: isJsonLd });
-  }
-
-  return { models };
-}

package/tools/generator/models/type-resolver.js

@@ -1,107 +0,0 @@
-import { schemaNameFromRef } from './schema-utils.js';
-import { quoteKeyIfNeeded } from './utils.js';
-
-/**
- * Ajoute | null à un type TS si le schéma est nullable (compat OAS 3.0),
- * sauf si 'null' est déjà présent dans l'union.
- * @param {string} ts
- * @param {any} schema
- */
-export function withNullable(ts, schema) {
-  return schema?.nullable && !/\|\s*null\b/.test(ts) ? `${ts} | null` : ts;
-}
-
-/**
- * Résout un schéma OpenAPI vers un type TypeScript, en collectant les dépendances ($ref)
- * @param {any} schema
- * @param {Set<string>} deps
- * @param {Map<string,string>} nameMap
- * @param {{ requiredMode?: 'all'|'spec' }} [cfg]
- * @returns {string}
- */
-export function tsTypeOf(schema, deps, nameMap, cfg) {
-  if (!schema) return 'any';
-  const requiredMode = cfg?.requiredMode ?? 'all';
-  const forceNullable = requiredMode !== 'spec';
-
-  if (schema.$ref) {
-    const orig = schemaNameFromRef(schema.$ref);
-    if (!orig) return 'any';
-    if (/jsonMergePatch/i.test(orig)) return 'any';
-    if (/^Hydra/i.test(orig)) return 'any';
-    const name = nameMap.get(orig) || orig;
-    deps.add(name);
-    return name;
-  }
-
-  // Enum prioritaires: union littérale (supporte null)
-  if (schema.enum) {
-    const lit = schema.enum.map((v) => {
-      if (v === null) return 'null';
-      if (typeof v === 'string') return `'${v.replace(/'/g, "\\'")}'`;
-      if (typeof v === 'number' || typeof v === 'bigint') return String(v);
-      if (typeof v === 'boolean') return v ? 'true' : 'false';
-      return 'any';
-    });
-    return [...new Set(lit)].join(' | ');
-  }
-
-  // OpenAPI 3.1: null explicite et tableau de types (union)
-  if (schema.type === 'null') return 'null';
-  if (Array.isArray(schema.type)) {
-    const parts = new Set();
-    for (const t of schema.type) {
-      if (t === 'null') parts.add('null');
-      else if (t === 'string') parts.add('string');
-      else if (t === 'integer' || t === 'number') parts.add('number');
-      else if (t === 'boolean') parts.add('boolean');
-      else if (t === 'array') parts.add(tsTypeOf({ type: 'array', items: schema.items }, deps, nameMap, cfg));
-      else if (t === 'object') {
-        const objTs = tsTypeOf(
-          { type: 'object', properties: schema.properties, required: schema.required, additionalProperties: schema.additionalProperties },
-          deps,
-          nameMap,
-          cfg
-        );
-        parts.add(objTs);
-      } else parts.add('any');
-    }
-    return [...parts].join(' | ');
-  }
-
-  if (schema.allOf) {
-    // Aplatir au niveau buildModelsFromOpenAPI; ici on combine si nécessaire
-    return schema.allOf.map((s) => tsTypeOf(s, deps, nameMap, cfg)).join(' & ');
-  }
-  if (schema.oneOf) return schema.oneOf.map((s) => tsTypeOf(s, deps, nameMap, cfg)).join(' | ');
-  if (schema.anyOf) return schema.anyOf.map((s) => tsTypeOf(s, deps, nameMap, cfg)).join(' | ');
-
-  if (schema.type === 'array') {
-    const it = tsTypeOf(schema.items || {}, deps, nameMap, cfg);
-    return `${it}[]`;
-  }
-
-  if (schema.type === 'object' || (schema.properties || schema.additionalProperties)) {
-    const props = schema.properties || {};
-    const entries = Object.entries(props);
-    const inline = entries.map(([k, v]) => {
-      const t0 = tsTypeOf(v, deps, nameMap, cfg);
-      const opt = requiredMode === 'spec' ? ((schema.required || []).includes(k) ? '' : '?') : '?';
-      const wantsNull = forceNullable || v?.nullable;
-      const nullable = wantsNull && !/\|\s*null\b/.test(t0) ? ' | null' : '';
-      const key = quoteKeyIfNeeded(k);
-      return `${key}${opt}: ${t0}${nullable};`;
-    });
-    if (schema.additionalProperties) {
-      const at = tsTypeOf(schema.additionalProperties, deps, nameMap, cfg);
-      inline.push(`[key: string]: ${at};`);
-    }
-    return `{ ${inline.join(' ')} }`;
-  }
-
-  if (schema.type === 'string') return 'string';
-  if (schema.type === 'integer' || schema.type === 'number') return 'number';
-  if (schema.type === 'boolean') return 'boolean';
-
-  return 'any';
-}

package/tools/generator/models/utils.js

@@ -1,62 +0,0 @@
-import fs from 'node:fs/promises';
-
-/**
- * Supprime et recrée un dossier (idempotent)
- * @param {string} dir
- */
-export async function ensureCleanDir(dir) {
-  await fs.rm(dir, { recursive: true, force: true });
-  await fs.mkdir(dir, { recursive: true });
-}
-
-const RESERVED = new Set([
-  'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield', 'let', 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'await', 'abstract', 'boolean', 'byte', 'char', 'double', 'final', 'float', 'goto', 'int', 'long', 'native', 'short', 'synchronized', 'throws', 'transient', 'volatile'
-]);
-
-/**
- * Construit un PascalCase à partir d’une liste de tokens
- * @param {string[]} tokens
- */
-export function pascalCase(tokens) {
-  return tokens
-    .filter(Boolean)
-    .map(t => t.replace(/^[^A-Za-z0-9]+|[^A-Za-z0-9]+$/g, ''))
-    .filter(Boolean)
-    .map(t => t.charAt(0).toUpperCase() + t.slice(1))
-    .join('');
-}
-
-/**
- * Nettoie et désambiguïse un nom de type TypeScript, en évitant les mots réservés
- * et collisions via un suffixe numérique.
- * @param {string} original
- * @param {Set<string>} used
- */
-export function sanitizeTypeName(original, used) {
-  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';
-  let unique = name, i = 2;
-  while (used.has(unique)) {
-    unique = name + i++;
-  }
-  used.add(unique);
-  return unique;
-}
-
-/**
- * Vérifie qu’une clé est un identifiant TS valide ET non réservé
- * @param {string} k
- */
-export function isValidTsIdentifier(k) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) && !RESERVED.has(k);
-}
-
-/**
- * Ajoute des quotes sur une clé si nécessaire (clé non valide en TS)
- * @param {string} k
- */
-export function quoteKeyIfNeeded(k) {
-  return isValidTsIdentifier(k) ? k : `'${k.replace(/'/g, "\\'")}'`;
-}

package/tools/infra/dev-support.js

@@ -1,189 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-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 isMeridianeSandboxApp(appRoot) {
-  const name = await readPackageJsonName(appRoot);
-  return name === '@obsidiane/meridiane-sandbox';
-}
-
-export 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.');
-}
-
-export async function resolveSandboxAppRoot(startCwd) {
-  if (await isMeridianeSandboxApp(startCwd)) return startCwd;
-
-  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.');
-}
-
-export async function resolveSpecSource({ useSandboxDefaults, appRoot, specArg }) {
-  if (!useSandboxDefaults) return specArg;
-  if (specArg) return specArg;
-  const localSpec = path.resolve(appRoot, '..', 'backend', 'var', 'openapi.json');
-  return (await pathIsFile(localSpec)) ? localSpec : 'http://localhost:8000/api/docs.json';
-}
-
-export 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;
-}
-
-export 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'),
-  });
-
-  await invalidateAngularViteDependencyCache({ appRoot, packageName, log });
-
-  return pkgDir;
-}
-
-async function invalidateAngularViteDependencyCache({ appRoot, packageName, log }) {
-  const viteDepsRoots = await findAngularViteDepsRoots(appRoot);
-  if (viteDepsRoots.length === 0) return;
-
-  const cacheBase = packageNameToViteCacheBase(packageName);
-  let removed = 0;
-
-  for (const depsRoot of viteDepsRoots) {
-    const files = [
-      `${cacheBase}.js`,
-      `${cacheBase}.js.map`,
-      `${cacheBase}.mjs`,
-      `${cacheBase}.mjs.map`,
-    ];
-
-    for (const fileName of files) {
-      const p = path.join(depsRoot, fileName);
-      try {
-        await fs.rm(p, { force: true });
-        removed += 1;
-      } catch {
-        // ignore
-      }
-    }
-
-    // Metadata keeps dependency hashes/entries; remove it to force a clean re-optimization.
-    try {
-      await fs.rm(path.join(depsRoot, '_metadata.json'), { force: true });
-      removed += 1;
-    } catch {
-      // ignore
-    }
-  }
-
-  if (removed > 0) {
-    log?.info?.(`cache Angular/Vite invalidé (${removed} fichier(s)) pour ${packageName}`);
-  }
-}
-
-function packageNameToViteCacheBase(packageName) {
-  const normalized = String(packageName || '').trim();
-  // Example: "@obsidiane/bridge-sandbox" -> "@obsidiane_bridge-sandbox"
-  return normalized.replace('/', '_');
-}
-
-async function findAngularViteDepsRoots(appRoot) {
-  const angularCacheRoot = path.join(appRoot, '.angular', 'cache');
-  const roots = [];
-
-  async function walk(dir, depth) {
-    if (depth > 8) return;
-
-    let entries;
-    try {
-      entries = await fs.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-
-    const hasDeps = entries.some((e) => e.isDirectory() && e.name === 'deps');
-    if (hasDeps && path.basename(dir) === 'vite') {
-      roots.push(path.join(dir, 'deps'));
-    }
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name === 'node_modules') continue;
-      await walk(path.join(dir, entry.name), depth + 1);
-    }
-  }
-
-  await walk(angularCacheRoot, 0);
-  return roots;
-}