@obsidiane/meridiane 0.0.6 → 0.0.7

package/tools/init.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import fs from 'node:fs/promises';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function hasFlag(name) {
+  return process.argv.includes(`--${name}`);
+}
+
+async function pathExists(p) {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(p) {
+  await fs.mkdir(p, {recursive: true});
+}
+
+async function writeFileIfMissing(filePath, content, {force} = {}) {
+  const exists = await pathExists(filePath);
+  if (exists && !force) return {written: false, reason: 'exists'};
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, 'utf8');
+  return {written: true};
+}
+
+async function copyFileIfMissing(src, dest, {force} = {}) {
+  const exists = await pathExists(dest);
+  if (exists && !force) return {written: false, reason: 'exists'};
+  await ensureDir(path.dirname(dest));
+  await fs.copyFile(src, dest);
+  return {written: true};
+}
+
+async function main() {
+  const force = hasFlag('force');
+  const debug = /^(1|true|yes)$/i.test(process.env.MERIDIANE_DEBUG ?? '') || hasFlag('debug');
+
+  const cwd = process.cwd();
+  const pkgRoot = path.resolve(__dirname, '..');
+
+  const outDir = path.resolve(cwd, 'meridiane');
+  await ensureDir(outDir);
+
+  const modelsExample = path.join(pkgRoot, 'models.config.example.js');
+  const modelsOut = path.resolve(cwd, 'models.config.js');
+  const envExampleOut = path.resolve(cwd, '.env.example');
+
+  const angularExampleOut = path.join(outDir, 'angular.example.ts');
+  const readmeOut = path.join(outDir, 'README.md');
+
+  if (debug) console.log('[meridiane init] cwd=', cwd);
+
+  const copiedCfg = await copyFileIfMissing(modelsExample, modelsOut, {force});
+  const wroteEnv = await writeFileIfMissing(
+    envExampleOut,
+    [
+      '# Meridiane (CLI) - exemple de configuration',
+      '# Copiez en `.env` pour activer la config locale.',
+      '',
+      '# Logs',
+      'MERIDIANE_DEBUG=0',
+      '',
+      '# meridiane lib',
+      '# MERIDIANE_LIB_VERSION=0.1.0',
+      '# MERIDIANE_NPM_REGISTRY_URL=https://registry.npmjs.org/',
+      '',
+      '# meridiane models',
+      '# MERIDIANE_MODELS_OUT=projects/backend-bridge/src/models',
+      '# MERIDIANE_MODELS_REQUIRED_MODE=spec',
+      '# MERIDIANE_MODELS_ITEM_IMPORT=../lib/ports/resource-repository.port',
+      '# MERIDIANE_MODELS_PRESET=all',
+      '# MERIDIANE_MODELS_INDEX=1',
+      '',
+      '# Runtime (Angular) - à recopier dans provideBridge(...)',
+      '# MERIDIANE_API_BASE_URL=http://localhost:8000',
+      '# MERIDIANE_MERCURE_HUB_URL=http://localhost:8000/.well-known/mercure',
+      '',
+    ].join('\n'),
+    {force}
+  );
+
+  const wroteAngular = await writeFileIfMissing(
+    angularExampleOut,
+    [
+      "import {provideBridge} from '@acme/backend-bridge';",
+      '',
+      'export const BRIDGE_PROVIDERS = [',
+      '  provideBridge({',
+      "    baseUrl: 'http://localhost:8000',",
+      '    mercure: {',
+      "      hubUrl: 'http://localhost:8000/.well-known/mercure',",
+      "      init: {credentials: 'include'},",
+      '    },',
+      '    defaults: {',
+      '      headers: {',
+      "        // 'X-Correlation-Id': crypto.randomUUID(),",
+      '      },',
+      '      timeoutMs: 30_000,',
+      '      retries: {count: 1, delayMs: 250},',
+      '    },',
+      '    // auth: {type: \"bearer\", token: \"<JWT>\"},',
+      '    debug: false,',
+      '  }),',
+      '];',
+      '',
+    ].join('\n'),
+    {force}
+  );
+
+  const wroteReadme = await writeFileIfMissing(
+    readmeOut,
+    [
+      '# Meridiane – fichiers générés',
+      '',
+      'Ces fichiers sont créés par `meridiane init` pour accélérer l’intégration.',
+      '',
+      '## CLI',
+      '',
+      '- `models.config.js` : configuration par défaut de `meridiane models` (chargée depuis le CWD).',
+      "- `.env` : optionnel. Le CLI charge automatiquement `.env` (CWD) avant d'exécuter `lib/models`.",
+      '',
+      '## Angular',
+      '',
+      '- `angular.example.ts` : exemple `provideBridge({ baseUrl, mercure, defaults, auth, debug })` à adapter.',
+      '',
+    ].join('\n'),
+    {force}
+  );
+
+  console.log('✅ meridiane init');
+  console.log(`- ${path.relative(cwd, modelsOut)} ${copiedCfg.written ? 'créé' : '(existe déjà)'}`);
+  console.log(`- ${path.relative(cwd, envExampleOut)} ${wroteEnv.written ? 'créé' : '(existe déjà)'}`);
+  console.log(`- ${path.relative(cwd, angularExampleOut)} ${wroteAngular.written ? 'créé' : '(existe déjà)'}`);
+  console.log(`- ${path.relative(cwd, readmeOut)} ${wroteReadme.written ? 'créé' : '(existe déjà)'}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tools/sandbox-bridge.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+import {loadDotEnv} from './utils/dotenv.js';
+import {getArg, hasFlag} from './utils/cli-args.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '../../..');
+
+function run(args) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, args, {stdio: 'inherit', env: process.env});
+    child.on('exit', (code) => resolve(code ?? 0));
+  });
+}
+
+function printHelp() {
+  console.log(`
+Usage:
+  meridiane sandbox-bridge [options]
+
+This command regenerates the Angular bridge library used by the sandbox:
+  - workspace: apps/sandbox
+  - libName: bridge-sandbox
+  - package: @obsidiane/bridge-sandbox
+  - version: 0.1.0 (override with --version)
+
+Options:
+  --backend=http://localhost:8000
+  --spec=/api/docs.json
+  --models-out=projects/bridge-sandbox/src/models
+  --required-mode=all-optional|spec
+  --preset=all|native
+  --include=<substr>[,<substr>…] (repeatable)
+  --exclude=<substr>[,<substr>…] (repeatable)
+  --index=1|0
+  --no-models
+  --debug
+
+Example:
+  npx -y @obsidiane/meridiane sandbox-bridge --backend=http://localhost:8000
+`);
+}
+
+async function main() {
+  await loadDotEnv();
+
+  if (hasFlag('help') || hasFlag('h')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const version = getArg('version', process.env.MERIDIANE_SANDBOX_BRIDGE_VERSION ?? '0.1.0');
+
+  const passThrough = process.argv.slice(2).filter((a) => a.startsWith('--') && !a.startsWith('--version='));
+
+  const devBridgePath = path.join(__dirname, 'dev-bridge.js');
+  const workspaceAbs = path.join(repoRoot, 'apps', 'sandbox');
+  const args = [
+    devBridgePath,
+    'bridge-sandbox',
+    '@obsidiane/bridge-sandbox',
+    version,
+    `--workspace=${workspaceAbs}`,
+    ...passThrough,
+  ];
+
+  const code = await run(args);
+  process.exit(code);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tools/utils/cli-args.js

@@ -0,0 +1,41 @@
+/**
+ * @param {string} name
+ * @param {string|undefined} def
+ * @param {string[]} [argv]
+ * @returns {string|undefined}
+ */
+export function getArg(name, def, argv = process.argv) {
+  const a = argv.find((x) => x.startsWith(`--${name}=`));
+  return a ? a.split('=')[1] : def;
+}
+
+/**
+ * @param {string} name
+ * @param {string[]} [argv]
+ * @returns {string[]}
+ */
+export function getArgs(name, argv = process.argv) {
+  return argv
+    .filter((x) => x.startsWith(`--${name}=`))
+    .map((x) => x.slice(`--${name}=`.length));
+}
+
+/**
+ * @param {string} name
+ * @param {string[]} [argv]
+ */
+export function hasFlag(name, argv = process.argv) {
+  return argv.includes(`--${name}`);
+}
+
+/**
+ * @param {unknown} v
+ * @param {boolean} def
+ */
+export function asBool(v, def) {
+  if (typeof v !== 'string') return def;
+  if (/^(1|true|yes)$/i.test(v)) return true;
+  if (/^(0|false|no)$/i.test(v)) return false;
+  return def;
+}
+

package/tools/utils/dotenv.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * Charge un fichier `.env` (format KEY=VALUE) dans process.env, sans écraser les variables déjà définies.
+ * @param {{cwd?: string, filename?: string}} [opts]
+ * @returns {Promise<Record<string, string>>} variables chargées
+ */
+export async function loadDotEnv(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const filename = opts.filename ?? '.env';
+  const envPath = await findUp(cwd, filename);
+  if (!envPath) return {};
+
+  const raw = await fs.readFile(envPath, 'utf8');
+
+  const loaded = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const normalized = trimmed.startsWith('export ') ? trimmed.slice('export '.length).trim() : trimmed;
+    const idx = normalized.indexOf('=');
+    if (idx < 0) continue;
+    const key = normalized.slice(0, idx).trim();
+    let value = normalized.slice(idx + 1).trim();
+    if (!key) continue;
+
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+      loaded[key] = value;
+    }
+  }
+
+  return loaded;
+}
+
+async function findUp(startDir, fileName) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path.join(dir, fileName);
+    try {
+      const st = await fs.stat(candidate);
+      if (st.isFile()) return candidate;
+    } catch {
+      // ignore
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}

package/templates/_lib_template/src/lib/bridge/credentials.policy.ts

@@ -1,9 +0,0 @@
-export class CredentialsPolicy {
-  constructor(private readonly init: unknown) {
-  }
-
-  withCredentials(): boolean {
-    const c = this.init as any;
-    return c?.withCredentials === true || c?.credentials === 'include';
-  }
-}

package/templates/_lib_template/src/lib/utils/utils.ts

@@ -1,21 +0,0 @@
-import {WritableSignal} from '@angular/core';
-import {Item} from '../ports/resource-repository.port';
-
-export function upsertInSignal(
-  signal: WritableSignal<readonly Item[]>,
-  item: Item,
-): void {
-  signal.update(items => {
-
-    const id = item['@id'];
-    const existingIndex = items.findIndex(it => it['@id'] === id);
-
-    if (existingIndex === -1) {
-      return [item, ...items];
-    }
-
-    const next = items.slice() as Item[];
-    next[existingIndex] = item;
-    return next;
-  });
-}