@obsidiane/meridiane 2.0.10 → 2.0.12

package/tools/infra/generate/bridge.js

@@ -1,212 +0,0 @@
-import fs from 'node:fs/promises';
-import {existsSync} from 'node:fs';
-import path from 'node:path';
-import {fileURLToPath} from 'node:url';
-
-import {readJson, writeJsonIfChanged} from '../json.js';
-import {renderTemplateToFile} from '../../generator/models/handlebars.js';
-import {ensureCleanDir} from '../../generator/models/utils.js';
-import {buildModelsFromOpenAPI} from '../../generator/models/openapi-to-models.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const pkgRoot = path.resolve(__dirname, '../../..'); // packages/meridiane
-
-async function readTextIfExists(filePath) {
-  try {
-    return await fs.readFile(filePath, 'utf8');
-  } catch {
-    return undefined;
-  }
-}
-
-async function appendProjectReadme({targetReadmePath, projectReadmePath, debug, log}) {
-  if (!projectReadmePath) return;
-
-  const projectReadme = await readTextIfExists(projectReadmePath);
-  if (!projectReadme || projectReadme.trim().length === 0) return;
-
-  const targetReadme = await readTextIfExists(targetReadmePath);
-  if (!targetReadme || targetReadme.trim().length === 0) {
-    await fs.writeFile(targetReadmePath, projectReadme);
-    if (debug) log?.debug?.('[meridiane] project README copied', {source: projectReadmePath});
-    return;
-  }
-
-  const combined =
-    `${targetReadme.trimEnd()}\n\n---\n\n` +
-    `## Documentation du projet\n\n` +
-    `${projectReadme.trimStart()}`;
-  await fs.writeFile(targetReadmePath, combined);
-  if (debug) log?.debug?.('[meridiane] project README appended', {source: projectReadmePath});
-}
-
-async function replacePlaceholdersInDir(dir, placeholders) {
-  const entries = await fs.readdir(dir, {withFileTypes: true});
-  for (const entry of entries) {
-    const fullPath = path.join(dir, 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)) {
-        content = content.replaceAll(key, value);
-      }
-      await fs.writeFile(fullPath, content);
-    }
-  }
-}
-
-async function generateLibrary({projectDir, libName, packageName, version, debug, log, projectReadmePath}) {
-  const tplDir = path.resolve(pkgRoot, 'templates/_lib_template');
-  const targetDir = projectDir;
-
-  if (debug) {
-    log?.debug?.('[meridiane] generate lib', {
-      libName,
-      packageName,
-      version,
-      targetDir
-    });
-  }
-
-  await fs.rm(targetDir, {recursive: true, force: true});
-  await fs.mkdir(targetDir, {recursive: true});
-  await fs.cp(tplDir, targetDir, {recursive: true});
-
-  await replacePlaceholdersInDir(targetDir, {
-    '__LIB_NAME__': libName,
-    '__PACKAGE_NAME__': packageName,
-  });
-
-  const libPackageJsonPath = path.join(targetDir, 'package.json');
-  if (existsSync(libPackageJsonPath)) {
-    const libPkg = await readJson(libPackageJsonPath);
-    libPkg.name = packageName;
-    libPkg.version = version;
-    await writeJsonIfChanged(libPackageJsonPath, libPkg);
-  }
-
-  await appendProjectReadme({
-    targetReadmePath: path.join(targetDir, 'README.md'),
-    projectReadmePath,
-    debug,
-    log,
-  });
-
-  // angular.json / workspace patching is intentionally not done here.
-}
-
-async function generateModels({projectDir, spec, requiredMode, formats, include, exclude, debug, log}) {
-  const outDir = path.resolve(projectDir, 'src', 'models');
-  const templatesDir = path.resolve(pkgRoot, 'tools', 'generator', 'models', 'templates');
-
-  if (debug) {
-    log?.debug?.('[meridiane] generate models', {
-      outDir,
-      requiredMode,
-      formats: Array.isArray(formats) ? formats : [],
-      includeCount: include.length,
-      excludeCount: exclude.length,
-    });
-  }
-
-  await ensureCleanDir(outDir);
-
-  // Write models + index.ts.
-  const {models} = buildModelsFromOpenAPI(spec, {
-    requiredMode,
-    formats: Array.isArray(formats) ? formats : [],
-    includeSchemaNames: include,
-    excludeSchemaNames: exclude,
-  });
-
-  for (const m of models) {
-    await renderTemplateToFile({
-      templatePath: path.join(templatesDir, 'model.hbs'),
-      outPath: path.join(outDir, `${m.name}.ts`),
-      ctx: {
-        name: m.name,
-        props: m.props,
-        imports: m.imports,
-        extendsTypes: m.extendsTypes || [],
-        extendsItem: m.extendsItem === true,
-      },
-    });
-  }
-
-  await renderTemplateToFile({
-    templatePath: path.join(templatesDir, 'index.hbs'),
-    outPath: path.join(outDir, 'index.ts'),
-    ctx: {models: models.map((m) => ({name: m.name}))},
-  });
-
-  if (debug) log?.debug?.(`[meridiane] ${models.length} model(s) generated`);
-}
-
-/**
- * @param {{
- *   cwd: string,
- *   libName: string,
- *   packageName: string,
- *   version: string,
- *   noModels: boolean,
- *   spec?: any,
- *   requiredMode: 'all'|'spec',
- *   formats?: string[],
- *   include: string[],
- *   exclude: string[],
- *   debug: boolean,
- *   log?: { step?: (msg: string) => void, info?: (msg: string) => void, success?: (msg: string) => void, debug?: (msg: string, data?: any) => void },
- *   workspaceMode?: 'angular'|'standalone',
- *   distRoot?: string,
- *   projectDir?: string,
- *   projectReadmePath?: string,
- * }} params
- */
-export async function generateBridgeWorkspace(params) {
-  const {
-    cwd,
-    libName,
-    packageName,
-    version,
-    noModels,
-    spec,
-    requiredMode,
-    formats,
-    include,
-    exclude,
-    debug,
-    log,
-    distRoot,
-    projectDir: projectDirInput,
-    projectReadmePath,
-  } = params;
-
-  const projectDir = projectDirInput ?? path.resolve(cwd, 'projects', libName);
-  log?.step?.(`génération de la librairie (${path.relative(cwd, projectDir)})`);
-  await generateLibrary({projectDir, libName, packageName, version, debug, log, projectReadmePath});
-
-  // If a dist root is provided, force ng-packagr output to that directory.
-  if (distRoot) {
-    const ngPackagePath = path.resolve(projectDir, 'ng-package.json');
-    const ngPkg = await readJson(ngPackagePath);
-    const desiredDestAbs = path.resolve(distRoot, libName);
-    const projectRoot = path.dirname(ngPackagePath);
-    ngPkg.dest = path.relative(projectRoot, desiredDestAbs).split(path.sep).join('/');
-    await writeJsonIfChanged(ngPackagePath, ngPkg);
-    log?.debug?.('ng-package.json dest overridden', {dest: ngPkg.dest});
-  }
-
-  if (noModels) {
-    log?.info?.('models ignorés (--no-models)');
-    if (debug) log?.debug?.('[meridiane] --no-models enabled, skipping models generation');
-    return;
-  }
-
-  if (!spec) throw new Error('Internal error: spec is required when noModels=false');
-  log?.step?.('génération des models (OpenAPI)');
-  await generateModels({projectDir, spec, requiredMode, formats, include, exclude, debug, log});
-  log?.success?.('génération terminée');
-}

package/tools/infra/spec-loader.js

@@ -1,59 +0,0 @@
-import fs from 'node:fs/promises';
-
-function isHttpUrl(v) {
-  return /^https?:\/\//i.test(String(v || ''));
-}
-
-async function fetchJson(url) {
-  let res;
-  try {
-    res = await fetch(url);
-  } catch (err) {
-    const msg = err?.message ?? String(err);
-    throw new Error(
-      `Spec fetch failed: ${url}\n` +
-        `Reason: ${msg}\n` +
-        `Tip: if your environment cannot access the network, use a local JSON file via --spec ./openapi.json`
-    );
-  }
-  if (!res.ok) {
-    const body = await res.text().catch(() => '');
-    throw new Error(`Spec fetch failed: ${res.status} ${res.statusText}${body ? `\n${body}` : ''}`);
-  }
-  return await res.json();
-}
-
-export async function readOpenApiSpec(specArg) {
-  if (!specArg) throw new Error('Missing --spec (url or JSON file path)');
-  const spec = String(specArg);
-
-  if (isHttpUrl(spec)) {
-    try {
-      return await fetchJson(spec);
-    } catch (err) {
-      const isDocsJson = /\/api\/docs\.json$/i.test(spec);
-      if (!isDocsJson) throw err;
-      const fallback = spec.replace(/\/api\/docs\.json$/i, '/api/docs.jsonopenapi');
-      try {
-        return await fetchJson(fallback);
-      } catch (err2) {
-        const m1 = err?.message ?? String(err);
-        const m2 = err2?.message ?? String(err2);
-        throw new Error(`Spec fetch failed (both endpoints tried)\n- ${spec}\n  ${m1}\n- ${fallback}\n  ${m2}`);
-      }
-    }
-  }
-
-  try {
-    const raw = await fs.readFile(spec, 'utf8');
-    return JSON.parse(raw);
-  } catch (err) {
-    if (err?.code === 'ENOENT') {
-      throw new Error(`Spec file not found: ${spec}`);
-    }
-    if (err?.name === 'SyntaxError') {
-      throw new Error(`Invalid JSON in spec file ${spec}: ${err.message}`);
-    }
-    throw err;
-  }
-}

package/tools/infra/standalone-workspace.js

@@ -1,162 +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 ensureDir(p) {
-  await fs.mkdir(p, { recursive: true });
-}
-
-async function exists(p) {
-  try {
-    await fs.stat(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function toolchainPackageJson({ angularVersion, ngPackagrVersion, typescriptVersion, rxjsVersion, tslibVersion }) {
-  const v = angularVersion;
-  return {
-    name: 'meridiane-standalone-workspace',
-    private: true,
-    description: 'Temporary workspace created by @obsidiane/meridiane (standalone build).',
-    devDependencies: {
-      '@angular/common': v,
-      '@angular/compiler': v,
-      '@angular/compiler-cli': v,
-      '@angular/core': v,
-      '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 ensureDir(distRoot);
-  await ensureDir(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 ensureDir(npmCacheDir);
-
-  const requireFromWs = createRequire(path.join(workspaceRoot, 'package.json'));
-
-  return { workspaceRoot, distRoot, npmCacheDir, requireFromWs };
-}
-
-async function detectToolchainVersions(repoRoot) {
-  const pkgPath = path.join(repoRoot, 'package.json');
-  try {
-    const raw = await fs.readFile(pkgPath, 'utf8');
-    const parsed = JSON.parse(raw);
-    const angularVersion = readDependencyVersion(parsed, '@angular/core');
-    const ngPackagrVersion = readDependencyVersion(parsed, 'ng-packagr');
-    const typescriptVersion = readDependencyVersion(parsed, 'typescript');
-    const rxjsVersion = readDependencyVersion(parsed, 'rxjs');
-    const tslibVersion = readDependencyVersion(parsed, 'tslib');
-    return { angularVersion, ngPackagrVersion, typescriptVersion, rxjsVersion, tslibVersion };
-  } catch {
-    return {};
-  }
-}
-
-function readDependencyVersion(pkg, depName) {
-  const deps = pkg?.dependencies || {};
-  const devDeps = pkg?.devDependencies || {};
-  const peerDeps = pkg?.peerDependencies || {};
-  const value = deps[depName] ?? devDeps[depName] ?? peerDeps[depName];
-  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 = (id) => {
-    try {
-      requireFromWs.resolve(id);
-      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 npmCmd = 'npm';
-  const args = ['install', '--silent', '--no-progress'];
-  const code = await runCommand(npmCmd, 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;
-}