@obsidiane/meridiane 0.0.6 → 0.0.7

package/tools/dev-bridge.js

@@ -0,0 +1,138 @@
+#!/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,17 +1,16 @@
 #!/usr/bin/env node
-import fs from "fs-extra"
-import path from "path"
-import { fileURLToPath } from 'url';
+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);
-/**
- * Recursively replace all placeholders in files under a directory
- * @param {string} srcDir - source directory path
- * @param {Object.<string,string>} placeholders - map of placeholder -> value
- */
+const __dirname = path.dirname(__filename);
+
 async function replacePlaceholdersInDir(srcDir, placeholders) {
-  const entries = await fs.readdir(srcDir, { withFileTypes: true });
+  const entries = await fs.readdir(srcDir, {withFileTypes: true});
   for (const entry of entries) {
     const fullPath = path.join(srcDir, entry.name);
     if (entry.isDirectory()) {
@@ -27,33 +26,37 @@ async function replacePlaceholdersInDir(srcDir, placeholders) {
   }
 }
 
-/**
- * Generate a new Angular library from template
- * @param {string} libName - folder and project name
- * @param {string} packageName - NPM package name (e.g. @org/lib)
- * @param {string} version - initial version for the package
- * @param {string} urlRegistry  - NPM registry url
- */
+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.copy(tplDir, targetDir);
+  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
+    '__VERSION__': version,
   };
   await replacePlaceholdersInDir(targetDir, placeholders);
 
   // 3) Update the library's package.json
   const libPackageJsonPath = path.join(targetDir, 'package.json');
-  if (await fs.pathExists(libPackageJsonPath)) {
-    const libPkg = await fs.readJson(libPackageJsonPath);
+  try {
+    const libPkg = await readJson(libPackageJsonPath);
     libPkg.name = packageName;
     libPkg.version = version;
     if (urlRegistry) {
@@ -62,39 +65,41 @@ async function generate(libName, packageName, version, urlRegistry) {
       delete libPkg.publishConfig.registry;
       if (Object.keys(libPkg.publishConfig).length === 0) delete libPkg.publishConfig;
     }
-    await fs.writeJson(libPackageJsonPath, libPkg, { spaces: 2 });
+    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 fs.readJson(angularJsonPath);
+  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`
+    architect: {
+      build: {
+        builder: '@angular/build:ng-packagr',
+        configurations: {
+          production: {
+            tsConfig: `projects/${libName}/tsconfig.lib.prod.json`,
+          },
+          development: {
+            tsConfig: `projects/${libName}/tsconfig.lib.json`,
           },
-          "development": {
-            "tsConfig": `projects/${libName}/tsconfig.lib.json`
-          }
         },
-        "defaultConfiguration": "production"
+        defaultConfiguration: 'production',
       },
-      "test": {
-        "builder": "@angular/build:karma",
-        "options": {
-          "tsConfig": `projects/${libName}/tsconfig.spec.json`
-        }
-      }
-    }
+      test: {
+        builder: '@angular/build:karma',
+        options: {
+          tsConfig: `projects/${libName}/tsconfig.spec.json`,
+        },
+      },
+    },
   };
-  await fs.writeJson(angularJsonPath, ng, { spaces: 2 });
+  await writeJson(angularJsonPath, ng);
 
   console.log(`✅ Library '${libName}' generated at projects/${libName}` +
     ` with package '${packageName}@${version}'`);
@@ -115,22 +120,32 @@ function findUpNodeModulePackageJson(startDir, packageName) {
   let dir = startDir;
   while (true) {
     const candidate = path.join(dir, 'node_modules', packageName, 'package.json');
-    if (fs.existsSync(candidate)) return candidate;
+    if (existsSync(candidate)) return candidate;
     const parent = path.dirname(dir);
     if (parent === dir) return undefined;
     dir = parent;
   }
 }
 
-// CLI args: node generate-lib.js <lib-name> <package-name> [version] <url-registry>
+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]
-const [,, libName, packageName, version = '0.0.1', urlRegistry] = process.argv;
+// + 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);
 }
 
-generate(libName, packageName, version, urlRegistry).catch(err => {
+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);
 });

package/tools/generate-models.js

@@ -7,20 +7,11 @@ import {fileURLToPath, pathToFileURL} from 'node:url';
 import {renderTemplateToFile} from './generator/models/handlebars.js';
 import {buildModelsFromOpenAPI} from './generator/models/openapi-to-models.js';
 import {ensureCleanDir} from './generator/models/utils.js';
+import {asBool, getArg, getArgs} from './utils/cli-args.js';
+import {loadDotEnv} from './utils/dotenv.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-/**
- * Récupère un argument CLI de la forme --name=value
- * @param {string} name
- * @param {string|undefined} def
- * @returns {string|undefined}
- */
-function getArg(name, def) {
-  const a = process.argv.find((x) => x.startsWith(`--${name}=`));
-  return a ? a.split('=')[1] : def;
-}
-
 /**
  * Lit la specification OpenAPI depuis une URL http(s) ou un chemin fichier JSON.
  * @param {string} specPathOrUrl
@@ -52,41 +43,104 @@ async function readSpec(specPathOrUrl) {
  * Le module peut exporter par défaut ou via export nommé.
  */
 async function loadUserConfig() {
-  const cfgPath = path.resolve(process.cwd(), 'models.config.js');
+  const cfgPath = await findUp(process.cwd(), 'models.config.js');
   try {
+    if (!cfgPath) return {};
     const st = await fs.stat(cfgPath);
     if (!st.isFile()) return {};
     const mod = await import(pathToFileURL(cfgPath).href);
-    return (mod?.default && typeof mod.default === 'object') ? mod.default : (mod || {});
+    const cfg = mod?.default ?? mod;
+    return (cfg && typeof cfg === 'object') ? cfg : {};
   } catch {
     return {};
   }
 }
+
+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;
+  }
+}
 async function main() {
+  await loadDotEnv();
+  const debug = process.argv.includes('--debug') || /^(1|true|yes)$/i.test(process.env.MERIDIANE_DEBUG ?? '');
+
   const specPathOrUrl = process.argv[2];
   if (!specPathOrUrl) {
-    console.error('Usage: generate-models.js <OpenAPI spec (url|fichier)> [--item-import=../lib/ports/resource-repository.port] [--out=models] [--required-mode=all-optional|spec] [--no-index]');
+    console.error('Usage: generate-models.js <OpenAPI spec (url|fichier)> [--item-import=../lib/ports/resource-repository.port] [--out=models] [--required-mode=all-optional|spec] [--preset=all|native] [--include=<substr>] [--exclude=<substr>] [--index=1|0]');
     process.exit(1);
   }
 
   const workDir = process.cwd();
   const userCfg = await loadUserConfig();
-  const outDir = path.resolve(workDir, getArg('out', userCfg.outDir || 'models'));
-  const writeIndex = !('' + process.argv.join(' ')).includes('--no-index');
-  const itemImportPath = getArg('item-import', userCfg.itemImportPath || '../lib/ports/resource-repository.port');
+  const outDir = path.resolve(workDir, getArg('out', userCfg.outDir || process.env.MERIDIANE_MODELS_OUT || 'models'));
+  const writeIndex = (() => {
+    const cli = getArg('index', undefined);
+    if (typeof cli === 'string') return asBool(cli, true);
+    if (typeof userCfg.writeIndex === 'boolean') return userCfg.writeIndex;
+    return asBool(process.env.MERIDIANE_MODELS_INDEX ?? '1', true);
+  })();
+  const itemImportPath = getArg(
+    'item-import',
+    userCfg.itemImportPath || process.env.MERIDIANE_MODELS_ITEM_IMPORT || '../lib/ports/resource-repository.port'
+  );
   const requiredMode = (() => {
-    const v = getArg('required-mode', userCfg.requiredMode || 'all-optional');
+    const v = getArg('required-mode', userCfg.requiredMode || process.env.MERIDIANE_MODELS_REQUIRED_MODE || 'all-optional');
     return (v === 'spec' || v === 'all-optional') ? v : 'all-optional';
   })();
+  const preset = (() => {
+    const v = getArg('preset', userCfg.preset || process.env.MERIDIANE_MODELS_PRESET || 'all');
+    return (v === 'native' || v === 'all') ? v : 'all';
+  })();
   const preferFlavor = userCfg.preferFlavor; // 'jsonld' | 'jsonapi' | 'none'
   const hydraBaseRegex = userCfg.hydraBaseRegex; // RegExp|string
+  const includeCli = getArgs('include').flatMap((v) => v.split(',').map((s) => s.trim()).filter(Boolean));
+  const excludeCli = getArgs('exclude').flatMap((v) => v.split(',').map((s) => s.trim()).filter(Boolean));
+  const includeSchemaNames = [
+    ...(Array.isArray(userCfg.includeSchemaNames) ? userCfg.includeSchemaNames : []),
+    ...includeCli,
+  ];
+  const excludeSchemaNames = [
+    ...(Array.isArray(userCfg.excludeSchemaNames) ? userCfg.excludeSchemaNames : []),
+    ...excludeCli,
+  ];
+
+  if (debug) {
+    console.log('[meridiane models] debug', {
+      outDir: path.relative(workDir, outDir),
+      writeIndex,
+      itemImportPath,
+      requiredMode,
+      preset,
+      preferFlavor,
+      includeCount: includeSchemaNames.length,
+      excludeCount: excludeSchemaNames.length,
+    });
+  }
 
   console.log(`📥 Spec OpenAPI: ${specPathOrUrl}`);
   const spec = await readSpec(specPathOrUrl);
 
 
   console.log('🔧 Construction des interfaces…');
-  const {models} = buildModelsFromOpenAPI(spec, { requiredMode, preferFlavor, hydraBaseRegex });
+  const {models} = buildModelsFromOpenAPI(spec, {
+    requiredMode,
+    preset,
+    preferFlavor,
+    hydraBaseRegex,
+    includeSchemaNames,
+    excludeSchemaNames,
+  });
 
   const templatesDir = path.join(__dirname, 'generator', 'models', 'templates');
   await ensureCleanDir(outDir);

package/tools/generator/models/openapi-to-models.js

@@ -1,8 +1,19 @@
 import { sanitizeTypeName, quoteKeyIfNeeded } from './utils.js';
-import { filterSchemaNames, mergeAllOf, isObject } from './schema-utils.js';
+import { filterSchemaNames, applySchemaNameFilters, mergeAllOf, isObject } from './schema-utils.js';
 import { friendlyName } from './naming.js';
 import { tsTypeOf, withNullable } from './type-resolver.js';
 
+/**
+ * @typedef {{
+ *   requiredMode?: 'all-optional'|'spec',
+ *   preferFlavor?: 'jsonld'|'jsonapi'|'none',
+ *   hydraBaseRegex?: RegExp|string,
+ *   preset?: 'all'|'native',
+ *   includeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ *   excludeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ * }} BuildOptions
+ */
+
 /**
  * Construit une map originalName -> sanitizedName, en assurant l’unicité
  * @param {string[]} schemaNames
@@ -53,7 +64,7 @@ function buildNameMap(schemaNames) {
 export function buildModelsFromOpenAPI(spec, options) {
   const opts = { requiredMode: 'all-optional', ...(options || {}) };
   const schemas = spec?.components?.schemas || {};
-  const schemaNames = filterSchemaNames(schemas, opts);
+  const schemaNames = applySchemaNameFilters(filterSchemaNames(schemas, opts), opts);
   const nameMap = buildNameMap(schemaNames);
   const allSanitizedNames = new Set([...nameMap.values()]);
 

package/tools/generator/models/schema-utils.js

@@ -123,3 +123,62 @@ export function filterSchemaNames(schemas, cfg) {
   const noGroupSelected = [...variantsNoGroup.values()];
   return [...roots, ...[...grouped.values()], ...noGroupSelected].sort((a, b) => a.localeCompare(b));
 }
+
+/**
+ * @param {unknown} rule
+ * @returns {rule is ((name: string) => boolean)}
+ */
+function isRuleFn(rule) {
+  return typeof rule === 'function';
+}
+
+/**
+ * @param {string} name
+ * @param {RegExp|string|((name: string) => boolean)} rule
+ */
+function matchesRule(name, rule) {
+  if (rule instanceof RegExp) return rule.test(name);
+  if (isRuleFn(rule)) return !!rule(name);
+  if (typeof rule === 'string' && rule.length) return name.includes(rule);
+  return false;
+}
+
+/**
+ * Applique un preset de génération et/ou des règles include/exclude.
+ *
+ * - `preset: "all"`: ne filtre rien (comportement par défaut)
+ * - `preset: "native"`: retire les schémas "techniques" (Hydra*, jsonMergePatch…)
+ *
+ * Les règles `includeSchemaNames` / `excludeSchemaNames` s'appliquent sur les noms
+ * de schémas OpenAPI (ex: "User-user.read", "Conversation.jsonMergePatch", …).
+ *
+ * @param {string[]} schemaNames
+ * @param {{
+ *   preset?: 'all'|'native',
+ *   includeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ *   excludeSchemaNames?: Array<RegExp|string|((name: string) => boolean)>,
+ * }} [cfg]
+ */
+export function applySchemaNameFilters(schemaNames, cfg) {
+  const preset = cfg?.preset ?? 'all';
+
+  /** @type {Array<RegExp|string|((name: string) => boolean)>} */
+  const include = Array.isArray(cfg?.includeSchemaNames) ? cfg.includeSchemaNames : [];
+  /** @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);
+  }
+
+  const hasInclude = include.length > 0;
+
+  return schemaNames.filter((name) => {
+    if (hasInclude && !include.some((r) => matchesRule(name, r))) return false;
+    if (exclude.some((r) => matchesRule(name, r))) return false;
+    return true;
+  });
+}

package/tools/generator/models/utils.js

@@ -33,8 +33,14 @@ export function pascalCase(tokens) {
  * @param {Set<string>} used
  */
 export function sanitizeTypeName(original, used) {
-  const base = original.includes('.') ? original.split('.').pop() : original;
-  const tokens = base.split(/[^A-Za-z0-9]+/);
+  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]+/);
   let name = pascalCase(tokens) || 'Model';
   if (/^[0-9]/.test(name)) name = '_' + name;
   if (RESERVED.has(name)) name = name + 'Model';