@obsidiane/meridiane 0.0.7 → 0.0.10

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,69 +48,13 @@ 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));
-
-  const roots = [];
-  const grouped = new Map();
-  const variantsNoGroup = new Map(); // base -> best variant (no '-')
-
-  for (const n of Object.keys(schemas)) {
-    if (hydraRe(cfg).test(n)) continue;
-
-    const hasGroup = n.includes('-');
-    const hasDot = n.includes('.');
-    const isJsonFlavor = /\.jsonld\b|\.jsonapi\b/i.test(n);
-
-    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);
-        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 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);
-  }
-  // Ajoute les variantes sans groupe sélectionnées
-  const noGroupSelected = [...variantsNoGroup.values()];
-  return [...roots, ...[...grouped.values()], ...noGroupSelected].sort((a, b) => a.localeCompare(b));
+  return Object.keys(schemas).sort((a, b) => a.localeCompare(b));
 }
 
 /**
@@ -167,18 +100,44 @@ export function applySchemaNameFilters(schemaNames, cfg) {
   /** @type {Array<RegExp|string|((name: string) => boolean)>} */
   const exclude = Array.isArray(cfg?.excludeSchemaNames) ? [...cfg.excludeSchemaNames] : [];
 
-  if (preset === 'native') {
-    exclude.push(/^Hydra/i);
-    exclude.push(/jsonMergePatch/i);
-    exclude.push(/\.jsonld\b/i);
-    exclude.push(/\.jsonapi\b/i);
-  }
-
+  // 1) include/exclude user filters (always applied first)
   const hasInclude = include.length > 0;
-
-  return schemaNames.filter((name) => {
+  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;
   });
+
+  // 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;
+      }
+      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);
+    }
+    out = [...byBase.values()].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,14 +33,7 @@ export function pascalCase(tokens) {
  * @param {Set<string>} used
  */
 export function sanitizeTypeName(original, used) {
-  const dotTail = original.includes('.') ? original.split('.').pop() : undefined;
-  const keepDottedName = typeof dotTail === 'string'
-    && ['jsonmergepatch', 'jsonpatch', 'mergepatch', 'jsonld', 'jsonapi'].includes(dotTail.toLowerCase());
-
-  // "Namespace-like" dotted names (ex: Workflow.WorkflowInput) default to the tail segment,
-  // but keep the full name for known format suffixes (ex: Conversation.jsonMergePatch) to avoid collisions.
-  const base = (dotTail && !keepDottedName) ? dotTail : original;
-  const tokens = String(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';

package/models.config.example.js

@@ -1,39 +0,0 @@
-// Exemple de configuration pour la génération des modèles.
-// Copiez ce fichier en `models.config.js` dans le dossier où vous lancez la commande (`meridiane models`).
-// Format CommonJS pour éviter les warnings Node dans la plupart des workspaces Angular.
-
-module.exports = {
-  // Dossier de sortie (relatif au CWD)
-  outDir: 'projects/backend-bridge/src/models',
-
-  // Chemin d'import de `Item` dans les templates (relatif au fichier généré)
-  itemImportPath: '../lib/ports/resource-repository.port',
-
-  // Contrôle des propriétés optionnelles
-  // - 'all-optional': toutes les props sont optionnelles
-  // - 'spec': respecte le tableau `required` de la spec
-  requiredMode: 'all-optional',
-
-  // Préférence entre variantes de schémas (.jsonld, .jsonapi ou aucune)
-  // Valeurs possibles: 'jsonld' | 'jsonapi' | 'none'
-  preferFlavor: 'jsonld',
-
-  // Preset de génération:
-  // - 'all' (défaut): génère tout ce qui ressemble à un objet
-  // - 'native': exclut les schémas "techniques" (Hydra*, jsonMergePatch…)
-  preset: 'all',
-
-  // Générer `index.ts` dans le dossier des models
-  writeIndex: true,
-
-  // Filtres additionnels (sur les noms OpenAPI des schémas, ex: "User-user.read", "Conversation.jsonMergePatch")
-  // - includeSchemaNames: si non vide, ne garde que les matchs
-  // - excludeSchemaNames: supprime les matchs
-  // Règles possibles: RegExp, string (substring), ou (name) => boolean.
-  includeSchemaNames: [],
-  excludeSchemaNames: [],
-
-  // Hydra: regex pour les schémas de base à ignorer (merge allOf / filtrage)
-  // Peut être une RegExp ou une string passée à `new RegExp(...)`
-  hydraBaseRegex: /^Hydra(?:Item|Collection)BaseSchema$/,
-};

package/templates/_lib_template/tsconfig.spec.json

@@ -1,14 +0,0 @@
-/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
-/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../out-tsc/spec",
-    "types": [
-      "jasmine"
-    ]
-  },
-  "include": [
-    "src/**/*.ts"
-  ]
-}

package/tools/dev-bridge.js

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-import process from 'node:process';
-import path from 'node:path';
-import {fileURLToPath} from 'node:url';
-import {spawn} from 'node:child_process';
-import {loadDotEnv} from './utils/dotenv.js';
-import {getArg, getArgs, hasFlag} from './utils/cli-args.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function normalizeBaseUrl(u) {
-  if (!u) return u;
-  return u.endsWith('/') ? u.slice(0, -1) : u;
-}
-
-function joinUrl(base, p) {
-  const b = normalizeBaseUrl(base);
-  if (!b) return p;
-  if (/^https?:\/\//i.test(p)) return p;
-  if (!p.startsWith('/')) return `${b}/${p}`;
-  return `${b}${p}`;
-}
-
-function runNode(scriptPath, args, {cwd} = {}) {
-  return new Promise((resolve) => {
-    const child = spawn(process.execPath, [scriptPath, ...args], {
-      stdio: 'inherit',
-      env: process.env,
-      cwd: cwd ?? process.cwd(),
-    });
-    child.on('exit', (code) => resolve(code ?? 0));
-  });
-}
-
-function printHelp() {
-  console.log(`
-Usage:
-  meridiane dev-bridge <lib-name> <npm-package-name> [version]
-
-Options:
-  --workspace=apps/sandbox               Working directory (default: current directory)
-  --backend=http://localhost:8000        Base URL of the backend (default: http://localhost:8000)
-  --spec=/api/docs.json                  Spec path or full URL (default: /api/docs.json)
-  --models-out=projects/<lib>/src/models Output dir for generated models
-  --required-mode=all-optional|spec      Models required-mode (default: all-optional)
-  --preset=all|native                    Models preset (default: all)
-  --include=<substr>[,<substr>…]         Include schema names (repeatable)
-  --exclude=<substr>[,<substr>…]         Exclude schema names (repeatable)
-  --index=1|0                             Generate index.ts (default: 1)
-  --no-models                            Skip models generation
-  --debug                                Enable debug logs
-
-Examples:
-  npx -y @obsidiane/meridiane dev-bridge bridge-sandbox @obsidiane/bridge-sandbox 0.1.0
-  npx -y @obsidiane/meridiane dev-bridge bridge-sandbox @obsidiane/bridge-sandbox 0.1.0 --workspace=apps/sandbox
-  npx -y @obsidiane/meridiane dev-bridge backend-bridge @acme/backend-bridge 0.1.0 --backend=http://localhost:8000 --workspace=apps/sandbox
-`);
-}
-
-async function main() {
-  await loadDotEnv();
-
-  const debug = hasFlag('debug') || /^(1|true|yes)$/i.test(process.env.MERIDIANE_DEBUG ?? '');
-  if (debug) process.env.MERIDIANE_DEBUG = '1';
-
-  const positional = process.argv.slice(2).filter((a) => !a.startsWith('--'));
-  const [libName, packageName, versionArg] = positional;
-  if (!libName || !packageName) {
-    printHelp();
-    process.exit(1);
-  }
-
-  const workspaceArg = getArg('workspace', process.env.MERIDIANE_DEV_WORKSPACE ?? '.');
-  const workspaceDir = path.resolve(process.cwd(), workspaceArg);
-
-  const backend = normalizeBaseUrl(getArg('backend', process.env.MERIDIANE_DEV_BACKEND ?? 'http://localhost:8000'));
-  const specArg = getArg('spec', process.env.MERIDIANE_DEV_SPEC ?? '/api/docs.json');
-  const specUrl = /^https?:\/\//i.test(specArg) ? specArg : joinUrl(backend, specArg);
-
-  const version = versionArg ?? process.env.MERIDIANE_LIB_VERSION ?? '0.0.1';
-  const urlRegistry = getArg('registry', process.env.MERIDIANE_NPM_REGISTRY_URL);
-
-  const toolsDir = __dirname;
-  const genLib = path.join(toolsDir, 'generate-lib.js');
-  const genModels = path.join(toolsDir, 'generate-models.js');
-
-  if (debug) {
-    console.log('[meridiane dev-bridge] config', {
-      workspaceDir,
-      backend,
-      specUrl,
-      libName,
-      packageName,
-      version,
-      urlRegistry: urlRegistry ? '<set>' : '<unset>',
-    });
-  }
-
-  // 1) Regenerate the library skeleton.
-  const libArgs = [libName, packageName, version, ...(urlRegistry ? [urlRegistry] : [])];
-  const libCode = await runNode(genLib, libArgs, {cwd: workspaceDir});
-  if (libCode !== 0) process.exit(libCode);
-
-  // 2) Generate models from the backend spec (dev-only convenience).
-  if (hasFlag('no-models')) return;
-
-  const modelsOut = getArg('models-out', `projects/${libName}/src/models`);
-  const requiredMode = getArg('required-mode', process.env.MERIDIANE_MODELS_REQUIRED_MODE ?? 'all-optional');
-  const preset = getArg('preset', process.env.MERIDIANE_MODELS_PRESET);
-  const include = getArgs('include');
-  const exclude = getArgs('exclude');
-  const index = getArg('index', process.env.MERIDIANE_MODELS_INDEX);
-
-  const modelsArgs = [
-    specUrl,
-    `--out=${modelsOut}`,
-    `--required-mode=${requiredMode}`,
-    ...(preset ? [`--preset=${preset}`] : []),
-    ...include.map((v) => `--include=${v}`),
-    ...exclude.map((v) => `--exclude=${v}`),
-    ...(index ? [`--index=${index}`] : []),
-  ];
-
-  // Try the configured URL first, then fallback to API Platform alternative endpoint.
-  let modelsCode = await runNode(genModels, modelsArgs, {cwd: workspaceDir});
-  if (modelsCode !== 0 && specUrl.endsWith('/api/docs.json')) {
-    const fallback = specUrl.replace(/\/api\/docs\.json$/, '/api/docs.jsonopenapi');
-    console.warn(`⚠️  Models generation failed for ${specUrl}, retrying with ${fallback}`);
-    modelsCode = await runNode(genModels, [fallback, ...modelsArgs.slice(1)], {cwd: workspaceDir});
-  }
-
-  process.exit(modelsCode);
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/tools/generate-lib.js

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import {existsSync} from 'node:fs';
-import path from 'node:path';
-import {fileURLToPath} from 'node:url';
-
-import {loadDotEnv} from './utils/dotenv.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-async function replacePlaceholdersInDir(srcDir, placeholders) {
-  const entries = await fs.readdir(srcDir, {withFileTypes: true});
-  for (const entry of entries) {
-    const fullPath = path.join(srcDir, entry.name);
-    if (entry.isDirectory()) {
-      await replacePlaceholdersInDir(fullPath, placeholders);
-    } else if (entry.isFile()) {
-      let content = await fs.readFile(fullPath, 'utf8');
-      for (const [key, value] of Object.entries(placeholders)) {
-        const regex = new RegExp(key, 'g');
-        content = content.replace(regex, value);
-      }
-      await fs.writeFile(fullPath, content);
-    }
-  }
-}
-
-async function readJson(filePath) {
-  const raw = await fs.readFile(filePath, 'utf8');
-  return JSON.parse(raw);
-}
-
-async function writeJson(filePath, data) {
-  await fs.writeFile(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
-}
-
-async function generate(libName, packageName, version, urlRegistry) {
-  const tplDir = path.resolve(__dirname, '../templates/_lib_template');
-  const workspaceRoot = process.cwd();
-  const targetDir = path.resolve(workspaceRoot, 'projects', libName);
-
-  // 1) Copy the template directory
-  await fs.rm(targetDir, {recursive: true, force: true});
-  await fs.mkdir(targetDir, {recursive: true});
-  await fs.cp(tplDir, targetDir, {recursive: true});
-
-  // 2) Replace placeholders __LIB_NAME__, __PACKAGE_NAME__, __VERSION__
-  const placeholders = {
-    '__LIB_NAME__': libName,
-    '__PACKAGE_NAME__': packageName,
-    '__VERSION__': version,
-  };
-  await replacePlaceholdersInDir(targetDir, placeholders);
-
-  // 3) Update the library's package.json
-  const libPackageJsonPath = path.join(targetDir, 'package.json');
-  try {
-    const libPkg = await readJson(libPackageJsonPath);
-    libPkg.name = packageName;
-    libPkg.version = version;
-    if (urlRegistry) {
-      libPkg.publishConfig = {...(libPkg.publishConfig || {}), registry: urlRegistry};
-    } else if (libPkg.publishConfig?.registry) {
-      delete libPkg.publishConfig.registry;
-      if (Object.keys(libPkg.publishConfig).length === 0) delete libPkg.publishConfig;
-    }
-    await writeJson(libPackageJsonPath, libPkg);
-  } catch {
-    // ignore: missing or invalid package.json in template
-  }
-
-  // 4) Update angular.json
-  const angularJsonPath = path.resolve(workspaceRoot, 'angular.json');
-  const ng = await readJson(angularJsonPath);
-
-  ng.projects[libName] = {
-    root: `projects/${libName}`,
-    sourceRoot: `projects/${libName}/src`,
-    projectType: 'library',
-    architect: {
-      build: {
-        builder: '@angular/build:ng-packagr',
-        configurations: {
-          production: {
-            tsConfig: `projects/${libName}/tsconfig.lib.prod.json`,
-          },
-          development: {
-            tsConfig: `projects/${libName}/tsconfig.lib.json`,
-          },
-        },
-        defaultConfiguration: 'production',
-      },
-      test: {
-        builder: '@angular/build:karma',
-        options: {
-          tsConfig: `projects/${libName}/tsconfig.spec.json`,
-        },
-      },
-    },
-  };
-  await writeJson(angularJsonPath, ng);
-
-  console.log(`✅ Library '${libName}' generated at projects/${libName}` +
-    ` with package '${packageName}@${version}'`);
-
-  const ngPackagrPkg = findUpNodeModulePackageJson(workspaceRoot, 'ng-packagr');
-  if (!ngPackagrPkg) {
-    console.warn(
-      [
-        "⚠️  'ng-packagr' n'est pas installé dans ce workspace.",
-        "   Pour builder une librairie (ng-packagr), installez-le dans votre projet Angular :",
-        "   npm i -D ng-packagr",
-      ].join('\n')
-    );
-  }
-}
-
-function findUpNodeModulePackageJson(startDir, packageName) {
-  let dir = startDir;
-  while (true) {
-    const candidate = path.join(dir, 'node_modules', packageName, 'package.json');
-    if (existsSync(candidate)) return candidate;
-    const parent = path.dirname(dir);
-    if (parent === dir) return undefined;
-    dir = parent;
-  }
-}
-
-await loadDotEnv();
-const debug = process.argv.includes('--debug') || /^(1|true|yes)$/i.test(process.env.MERIDIANE_DEBUG ?? '');
-
-// CLI args: node generate-lib.js <lib-name> <package-name> [version] [url-registry]
-// + support .env via MERIDIANE_LIB_VERSION / MERIDIANE_NPM_REGISTRY_URL
-const positional = process.argv.slice(2).filter((a) => !a.startsWith('--'));
-const [libName, packageName, versionArg, urlRegistryArg] = positional;
-const version = versionArg ?? process.env.MERIDIANE_LIB_VERSION ?? '0.0.1';
-const urlRegistry = urlRegistryArg ?? process.env.MERIDIANE_NPM_REGISTRY_URL;
-if (!libName || !packageName) {
-  console.error('Usage: generate-lib.js <lib-name> <package-name> [version] [url-registry]');
-  process.exit(1);
-}
-
-if (debug) {
-  console.log('[meridiane lib] debug', {libName, packageName, version, urlRegistry: urlRegistry ? '<set>' : '<unset>'});
-}
-
-generate(libName, packageName, version, urlRegistry).catch((err) => {
-  console.error(err);
-  process.exit(1);
-});