@obsidiane/meridiane 0.0.6 → 0.0.10

package/tools/build.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+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));
+  });
+}
+
+export async function runBuild(packageName, opts) {
+  const cwd = process.cwd();
+  const debug = !!opts.debug;
+  const log = createLogger({ debug });
+
+  const version = opts.version;
+  if (!version) throw new Error('Missing --version');
+
+  const noModels = opts.models === false;
+  const preset = normalizePreset(opts.preset);
+  const include = splitListArgs(opts.include);
+  const exclude = splitListArgs(opts.exclude);
+
+  const libName = deriveLibName(packageName);
+  const requiredMode = 'spec';
+
+  // Standalone mode (native): works from any repo (backend pipeline or otherwise).
+  log.title('build — standalone');
+  log.info(`repo: ${cwd}`);
+  log.info(`package: ${packageName}@${version}`);
+  log.info(`lib: ${libName}`);
+  if (noModels) log.info('models: désactivés (--no-models)');
+  else log.info(`spec: ${opts.spec} | preset: ${preset}`);
+
+  const { workspaceRoot, distRoot, npmCacheDir, requireFromWs } = await ensureStandaloneWorkspace({ repoRoot: cwd, log });
+  log.info(`workspace: ${workspaceRoot}`);
+
+  let spec;
+  if (!noModels) {
+    log.step('lecture de la spec OpenAPI');
+    spec = await readOpenApiSpec(opts.spec);
+    log.success('spec chargée');
+  }
+
+  await ensureToolchainInstalled({ workspaceRoot, requireFromWs, npmCacheDir, log });
+
+  await generateBridgeWorkspace({
+    cwd: workspaceRoot,
+    libName,
+    packageName,
+    version,
+    noModels,
+    spec,
+    requiredMode,
+    preset,
+    include,
+    exclude,
+    debug,
+    log,
+    distRoot,
+  });
+
+  const ngPackageJsonPath = path.join(workspaceRoot, 'projects', libName, 'ng-package.json');
+  const tsconfigProdPath = path.join(workspaceRoot, 'projects', libName, 'tsconfig.lib.prod.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', tsconfigProdPath], {
+    cwd: workspaceRoot,
+  });
+  if (packagrCode !== 0) process.exit(packagrCode);
+
+  const distDir = path.join(distRoot, libName);
+  log.step(`npm pack (${path.relative(cwd, 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) log.success(`package prêt: ${path.relative(cwd, distDir)}`);
+  process.exit(packCode);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  throw new Error('This module is not meant to be executed directly.');
+}

package/tools/core/generate.js

@@ -0,0 +1,152 @@
+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 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({ cwd, libName, packageName, version, debug }) {
+  const tplDir = path.resolve(pkgRoot, 'templates/_lib_template');
+  const targetDir = path.resolve(cwd, 'projects', libName);
+
+  if (debug) console.log('[meridiane] generate lib', { libName, packageName, version, targetDir: path.relative(cwd, 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 });
+
+  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);
+  }
+
+  // angular.json / workspace patching is intentionally not done here (Meridiane is standalone).
+}
+
+async function generateModels({ cwd, libName, spec, requiredMode, preset, include, exclude, debug }) {
+  const outDir = path.resolve(cwd, 'projects', libName, 'src', 'models');
+  const templatesDir = path.resolve(pkgRoot, 'tools', 'generator', 'models', 'templates');
+
+  if (debug) console.log('[meridiane] generate models', { outDir: path.relative(cwd, outDir), requiredMode, preset, includeCount: include.length, excludeCount: exclude.length });
+
+  await ensureCleanDir(outDir);
+
+  // Write models + index.ts.
+  const { models } = buildModelsFromOpenAPI(spec, {
+    requiredMode,
+    preset,
+    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 || [],
+      },
+    });
+  }
+
+  await renderTemplateToFile({
+    templatePath: path.join(templatesDir, 'index.hbs'),
+    outPath: path.join(outDir, 'index.ts'),
+    ctx: { models: models.map((m) => ({ name: m.name })) },
+  });
+
+  if (debug) console.log(`[meridiane] ${models.length} model(s) generated`);
+}
+
+/**
+ * @param {{
+ *   cwd: string,
+ *   libName: string,
+ *   packageName: string,
+ *   version: string,
+ *   noModels: boolean,
+ *   spec?: any,
+ *   requiredMode: 'all-optional'|'spec',
+ *   preset: 'all'|'native',
+ *   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,
+ * }} params
+ */
+export async function generateBridgeWorkspace(params) {
+  const {
+    cwd,
+    libName,
+    packageName,
+    version,
+    noModels,
+    spec,
+    requiredMode,
+    preset,
+    include,
+    exclude,
+    debug,
+    log,
+    distRoot,
+  } = params;
+
+  log?.step?.(`génération de la librairie (projects/${libName})`);
+  await generateLibrary({ cwd, libName, packageName, version, debug });
+
+  // If a dist root is provided, force ng-packagr output to that directory.
+  if (distRoot) {
+    const ngPackagePath = path.resolve(cwd, 'projects', libName, 'ng-package.json');
+    const ngPkg = await readJson(ngPackagePath);
+    const desiredDestAbs = path.resolve(distRoot, libName);
+    const projectDir = path.dirname(ngPackagePath);
+    ngPkg.dest = path.relative(projectDir, 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) console.log('[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({ cwd, libName, spec, requiredMode, preset, include, exclude, debug });
+  log?.success?.('génération terminée');
+}

package/tools/core/json.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs/promises';
+
+function stripJsonComments(input) {
+  let out = '';
+  let i = 0;
+  let inString = false;
+  let stringQuote = '"';
+  while (i < input.length) {
+    const ch = input[i];
+
+    if (inString) {
+      out += ch;
+      if (ch === '\\') {
+        // skip escaped char
+        i += 2;
+        continue;
+      }
+      if (ch === stringQuote) inString = false;
+      i += 1;
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      stringQuote = ch;
+      out += ch;
+      i += 1;
+      continue;
+    }
+
+    // line comment
+    if (ch === '/' && input[i + 1] === '/') {
+      i += 2;
+      while (i < input.length && input[i] !== '\n') i += 1;
+      continue;
+    }
+
+    // block comment
+    if (ch === '/' && input[i + 1] === '*') {
+      i += 2;
+      while (i < input.length && !(input[i] === '*' && input[i + 1] === '/')) i += 1;
+      i += 2;
+      continue;
+    }
+
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+
+export async function readJson(filePath) {
+  const raw = await fs.readFile(filePath, 'utf8');
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return JSON.parse(stripJsonComments(raw));
+  }
+}
+
+export async function writeJsonIfChanged(filePath, data) {
+  const next = JSON.stringify(data, null, 2) + '\n';
+  try {
+    const prev = await fs.readFile(filePath, 'utf8');
+    if (prev === next) return false;
+  } catch {
+    // ignore (file missing / unreadable)
+  }
+  await fs.writeFile(filePath, next, 'utf8');
+  return true;
+}

package/tools/core/lib-name.js

@@ -0,0 +1,15 @@
+export function deriveLibName(packageName) {
+  const raw = String(packageName || '').trim();
+  if (!raw) throw new Error('Missing packageName');
+
+  const base = raw.startsWith('@') ? (raw.split('/')[1] || '') : raw;
+  const normalized = base
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+
+  if (!normalized) throw new Error(`Invalid packageName: ${packageName}`);
+  return normalized;
+}
+

package/tools/core/logger.js

@@ -0,0 +1,51 @@
+import process from 'node:process';
+
+function color(code, text) {
+  if (!process.stdout.isTTY) return text;
+  return `\u001b[${code}m${text}\u001b[0m`;
+}
+
+function line(prefix, text) {
+  return `${prefix} ${text}`;
+}
+
+export function createLogger({ debug = false } = {}) {
+  const prefix = color('35', 'meridiane');
+
+  return {
+    debugEnabled: debug,
+
+    title(text) {
+      console.log(line('🌙', `${prefix} ${text}`));
+    },
+
+    step(text) {
+      console.log(line('🔧', `${prefix} ${text}`));
+    },
+
+    info(text) {
+      console.log(line('ℹ️', `${prefix} ${text}`));
+    },
+
+    success(text) {
+      console.log(line('✅', `${prefix} ${text}`));
+    },
+
+    warn(text) {
+      console.warn(line('⚠️', `${prefix} ${text}`));
+    },
+
+    debug(text, data) {
+      if (!debug) return;
+      if (data === undefined) console.log(line('🐛', `${prefix} ${text}`));
+      else console.log(line('🐛', `${prefix} ${text} ${JSON.stringify(data, null, 2)}`));
+    },
+
+    error(err) {
+      const msg = err?.message ?? String(err);
+      console.error(line('❌', `${prefix} ${msg}`));
+      if (debug && err?.stack) console.error(err.stack);
+    },
+  };
+}
+

package/tools/core/paths.js

@@ -0,0 +1,17 @@
+export function normalizePreset(presetOption) {
+  if (presetOption === undefined) return 'all';
+  if (presetOption === true) return 'native';
+  if (presetOption === 'native' || presetOption === 'all') return presetOption;
+  throw new Error(`Invalid --preset value: ${presetOption} (expected: native|all)`);
+}
+
+export function splitListArgs(values) {
+  const out = [];
+  for (const v of Array.isArray(values) ? values : []) {
+    for (const part of String(v).split(',')) {
+      const s = part.trim();
+      if (s) out.push(s);
+    }
+  }
+  return out;
+}

package/tools/core/spec.js

@@ -0,0 +1,59 @@
+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/core/standalone.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+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 }) {
+  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': '20.1.0',
+      rxjs: '7.8.2',
+      tslib: '2.8.1',
+      typescript: '5.8.3',
+    },
+  };
+}
+
+function rootTsconfigJson() {
+  return {
+    compilerOptions: {
+      target: 'ES2022',
+      module: 'ES2022',
+      moduleResolution: 'Node',
+      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 angularVersion = '20.1.7';
+  await writeJsonIfChanged(path.join(workspaceRoot, 'package.json'), toolchainPackageJson({ angularVersion }));
+  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 };
+}
+
+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 { spawn } = await import('node:child_process');
+
+  const code = await new Promise((resolve) => {
+    const child = spawn(npmCmd, args, { cwd: workspaceRoot, stdio: 'inherit', env });
+    child.on('exit', (c) => resolve(c ?? 0));
+  });
+
+  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;
+}
+