@obsidiane/meridiane 2.0.11 → 2.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obsidiane/meridiane",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "description": "Générateur de librairie Angular et modèles TypeScript (OpenAPI) pour un bridge Symfony/API Platform + Mercure.",
   "repository": {
     "type": "git",
@@ -23,11 +23,18 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=20.19"
+    "node": ">=24.0.0"
   },
   "dependencies": {
+    "@angular/common": "20.3.29",
+    "@angular/compiler": "20.3.29",
+    "@angular/compiler-cli": "20.3.29",
+    "@angular/core": "20.3.29",
     "commander": "^14.0.3",
-    "handlebars": "^4.7.8",
-    "tslib": "^2.3.0"
+    "handlebars": "^4.7.9",
+    "ng-packagr": "20.3.2",
+    "rxjs": "7.8.2",
+    "tslib": "^2.8.1",
+    "typescript": "5.9.3"
   }
 }

package/src/application/bridge-workflow.js

@@ -1,12 +1,14 @@
 import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
 
 import { generateBridgeWorkspace } from './generate-bridge.js';
 import { readOpenApiSpec } from '../infrastructure/spec-loader.js';
-import { ensureStandaloneWorkspace, ensureToolchainInstalled } from '../infrastructure/standalone-workspace.js';
 import { ExitCodeError, runCommand } from '../infrastructure/exec.js';
 
+const ngPackagrPath = fileURLToPath(import.meta.resolve('ng-packagr/src/cli/main.js'));
+
 export async function runBridgeWorkflow({
   repoRoot,
   libName,
@@ -25,15 +27,17 @@ export async function runBridgeWorkflow({
   packRelativeTo,
   projectReadmePath,
 }) {
-  const { workspaceRoot, distRoot, npmCacheDir, requireFromWs } = await ensureStandaloneWorkspace({ repoRoot, log });
-  log?.info?.(`workspace: ${workspaceRoot}`);
+  const distRoot = path.join(repoRoot, 'dist');
+  const buildRoot = path.join(distRoot, '.meridiane-workspace');
+  const npmCacheDir = path.join(buildRoot, '.npm-cache');
+  await fs.rm(buildRoot, { recursive: true, force: true });
+  await fs.mkdir(buildRoot, { recursive: true });
+  log?.info?.(`workspace: ${buildRoot}`);
 
   const resolvedSpec = await loadSpecIfNeeded({ noModels, spec, specSource, log });
 
-  await ensureToolchainInstalled({ workspaceRoot, requireFromWs, npmCacheDir, log });
-
   await generateBridgeWorkspace({
-    cwd: workspaceRoot,
+    cwd: buildRoot,
     libName,
     packageName,
     version,
@@ -49,13 +53,13 @@ export async function runBridgeWorkflow({
     projectReadmePath,
   });
 
-  const ngPackageJsonPath = path.join(workspaceRoot, 'projects', libName, 'ng-package.json');
-  const tsconfigAbsPath = path.join(workspaceRoot, 'projects', libName, tsconfigPath);
+  const projectDir = path.join(buildRoot, 'projects', libName);
+  const ngPackageJsonPath = path.join(projectDir, 'ng-package.json');
+  const tsconfigAbsPath = path.join(projectDir, tsconfigPath);
 
   log?.step?.('ng-packagr');
-  const ngPackagrPath = requireFromWs.resolve('ng-packagr/src/cli/main.js');
   const packagrCode = await runCommand(process.execPath, [ngPackagrPath, '-p', ngPackageJsonPath, '-c', tsconfigAbsPath], {
-    cwd: workspaceRoot,
+    cwd: buildRoot,
   });
   if (packagrCode !== 0) throw new ExitCodeError(`ng-packagr failed (exit ${packagrCode})`, packagrCode);
 
@@ -75,7 +79,7 @@ export async function runBridgeWorkflow({
   });
   if (packCode !== 0) throw new ExitCodeError(`npm pack failed (exit ${packCode})`, packCode);
 
-  return { workspaceRoot, distRoot, distDir, npmCacheDir };
+  return { distDir };
 }
 
 async function loadSpecIfNeeded({ noModels, spec, specSource, log }) {

package/templates/angular-bridge/tsconfig.lib.json

@@ -1,8 +1,15 @@
 /* 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": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
     "outDir": "../../out-tsc/lib",
     "declaration": true,
     "declarationMap": true,
@@ -14,5 +21,9 @@
   ],
   "exclude": [
     "**/*.spec.ts"
-  ]
+  ],
+  "angularCompilerOptions": {
+    "compilationMode": "partial",
+    "strictTemplates": true
+  }
 }

package/src/infrastructure/standalone-workspace.js

@@ -1,164 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-
-import { runCommand } from './exec.js';
-import { writeJsonIfChanged } from './json.js';
-
-async function ensureDirectory(directory) {
-  await fs.mkdir(directory, { recursive: true });
-}
-
-async function exists(filePath) {
-  try {
-    await fs.stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function toolchainPackageJson({ angularVersion, ngPackagrVersion, typescriptVersion, rxjsVersion, tslibVersion }) {
-  return {
-    name: 'meridiane-standalone-workspace',
-    private: true,
-    description: 'Temporary workspace created by @obsidiane/meridiane (standalone build).',
-    devDependencies: {
-      '@angular/common': angularVersion,
-      '@angular/compiler': angularVersion,
-      '@angular/compiler-cli': angularVersion,
-      '@angular/core': angularVersion,
-      'ng-packagr': ngPackagrVersion,
-      rxjs: rxjsVersion,
-      tslib: tslibVersion,
-      typescript: typescriptVersion,
-    },
-  };
-}
-
-function rootTsconfigJson() {
-  return {
-    compilerOptions: {
-      target: 'ES2022',
-      module: 'ES2022',
-      // Angular >=21 relies on modern package exports resolution for some subpaths
-      // (e.g. @angular/common/http, @angular/core/rxjs-interop).
-      moduleResolution: 'bundler',
-      lib: ['ES2022', 'DOM'],
-      strict: true,
-      skipLibCheck: true,
-      experimentalDecorators: true,
-      importHelpers: true,
-    },
-    angularCompilerOptions: {
-      compilationMode: 'partial',
-      strictTemplates: true,
-    },
-  };
-}
-
-export async function ensureStandaloneWorkspace({ repoRoot, log }) {
-  const distRoot = path.join(repoRoot, 'dist');
-  const workspaceRoot = path.join(distRoot, '.meridiane-workspace');
-
-  await ensureDirectory(distRoot);
-  await ensureDirectory(workspaceRoot);
-
-  const detected = await detectToolchainVersions(repoRoot);
-  const angularVersion = detected.angularVersion ?? '21.1.4';
-  const derived = deriveToolchainDefaultsFromAngular(angularVersion);
-  const ngPackagrVersion = detected.ngPackagrVersion ?? derived.ngPackagrVersion;
-  const typescriptVersion = detected.typescriptVersion ?? derived.typescriptVersion;
-  const rxjsVersion = detected.rxjsVersion ?? '7.8.2';
-  const tslibVersion = detected.tslibVersion ?? '2.8.1';
-  log?.debug?.('[meridiane] angular version', { angularVersion });
-  await writeJsonIfChanged(
-    path.join(workspaceRoot, 'package.json'),
-    toolchainPackageJson({ angularVersion, ngPackagrVersion, typescriptVersion, rxjsVersion, tslibVersion })
-  );
-  await writeJsonIfChanged(path.join(workspaceRoot, 'tsconfig.json'), rootTsconfigJson());
-
-  const npmCacheDir = path.join(workspaceRoot, '.npm-cache');
-  await ensureDirectory(npmCacheDir);
-
-  const requireFromWs = createRequire(path.join(workspaceRoot, 'package.json'));
-
-  return { workspaceRoot, distRoot, npmCacheDir, requireFromWs };
-}
-
-async function detectToolchainVersions(repoRoot) {
-  const packageJsonPath = path.join(repoRoot, 'package.json');
-  try {
-    const content = await fs.readFile(packageJsonPath, 'utf8');
-    const packageJson = JSON.parse(content);
-    const angularVersion = readDependencyVersion(packageJson, '@angular/core');
-    const ngPackagrVersion = readDependencyVersion(packageJson, 'ng-packagr');
-    const typescriptVersion = readDependencyVersion(packageJson, 'typescript');
-    const rxjsVersion = readDependencyVersion(packageJson, 'rxjs');
-    const tslibVersion = readDependencyVersion(packageJson, 'tslib');
-    return { angularVersion, ngPackagrVersion, typescriptVersion, rxjsVersion, tslibVersion };
-  } catch {
-    return {};
-  }
-}
-
-function readDependencyVersion(packageJson, dependencyName) {
-  const dependencies = packageJson?.dependencies || {};
-  const devDependencies = packageJson?.devDependencies || {};
-  const peerDependencies = packageJson?.peerDependencies || {};
-  const value =
-    dependencies[dependencyName] ??
-    devDependencies[dependencyName] ??
-    peerDependencies[dependencyName];
-  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-function deriveToolchainDefaultsFromAngular(angularVersion) {
-  const major = parseInt(String(angularVersion).match(/\d+/)?.[0] ?? '0', 10);
-  if (major >= 21) {
-    return {
-      ngPackagrVersion: '21.1.0',
-      typescriptVersion: '5.9.3',
-    };
-  }
-  return {
-    ngPackagrVersion: '20.1.0',
-    typescriptVersion: '5.8.3',
-  };
-}
-
-export async function ensureToolchainInstalled({ workspaceRoot, requireFromWs, npmCacheDir, log }) {
-  // Prefer using existing (hoisted) deps during local dev; in CI this will trigger installation.
-  const canResolve = (packageId) => {
-    try {
-      requireFromWs.resolve(packageId);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-
-  if (canResolve('ng-packagr/package.json')) return false;
-
-  log?.step?.('installation du toolchain (Angular + ng-packagr)');
-
-  // Use npm with a local cache to avoid writing to ~/.npm.
-  const env = {
-    ...process.env,
-    npm_config_cache: npmCacheDir,
-    npm_config_update_notifier: 'false',
-    npm_config_fund: 'false',
-    npm_config_audit: 'false',
-  };
-
-  // We avoid generating a lockfile in the backend repo by keeping everything under dist/.
-  const npmCommand = 'npm';
-  const args = ['install', '--silent', '--no-progress'];
-  const code = await runCommand(npmCommand, args, { cwd: workspaceRoot, env });
-
-  if (code !== 0) throw new Error(`Toolchain install failed (npm exit ${code})`);
-  if (!(await exists(path.join(workspaceRoot, 'node_modules')))) {
-    throw new Error('Toolchain install failed: node_modules missing');
-  }
-  return true;
-}