@obsidiane/meridiane 0.0.7 → 0.0.11

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;
+}
+

package/tools/dev.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+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));
+  });
+}
+
+async function pathIsFile(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function readPackageJsonName(dir) {
+  try {
+    const raw = await fs.readFile(path.join(dir, 'package.json'), 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed?.name === 'string' ? parsed.name : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveDevAppRoot(startCwd) {
+  if (await pathIsFile(path.join(startCwd, 'package.json'))) return startCwd;
+  throw new Error('No package.json found. Run `meridiane dev` from your Angular app root.');
+}
+
+async function isMeridianeSandboxApp(appRoot) {
+  const name = await readPackageJsonName(appRoot);
+  return name === '@obsidiane/meridiane-sandbox';
+}
+
+async function resolveSandboxAppRoot(startCwd) {
+  // Allow running from apps/sandbox directly
+  if (await isMeridianeSandboxApp(startCwd)) return startCwd;
+
+  // Allow running from this repo root (monorepo) and target apps/sandbox
+  const sandboxApp = path.join(startCwd, 'apps', 'sandbox');
+  if (await pathIsFile(path.join(sandboxApp, 'package.json')) && (await isMeridianeSandboxApp(sandboxApp))) {
+    return sandboxApp;
+  }
+
+  throw new Error('Missing <packageName>. Run from the sandbox app (`apps/sandbox`) or provide a package name.');
+}
+
+async function findLatestTgz(distDir) {
+  const entries = await fs.readdir(distDir, { withFileTypes: true }).catch(() => []);
+  const tgzFiles = [];
+  for (const e of entries) {
+    if (!e.isFile()) continue;
+    if (!e.name.endsWith('.tgz')) continue;
+    const full = path.join(distDir, e.name);
+    const st = await fs.stat(full);
+    tgzFiles.push({ full, mtimeMs: st.mtimeMs });
+  }
+  tgzFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return tgzFiles[0]?.full;
+}
+
+function splitPackageName(packageName) {
+  const s = String(packageName || '').trim();
+  if (!s) throw new Error('Missing packageName');
+  if (s.startsWith('@')) {
+    const [scope, name] = s.split('/');
+    if (!scope || !name) throw new Error(`Invalid packageName: ${packageName}`);
+    return { scope, name };
+  }
+  return { scope: undefined, name: s };
+}
+
+async function resolveNodeModulesRoot(startDir) {
+  let cur = startDir;
+  for (;;) {
+    const candidate = path.join(cur, 'node_modules');
+    try {
+      const st = await fs.stat(candidate);
+      if (st.isDirectory()) return candidate;
+    } catch {
+      // ignore
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+
+  const nm = path.join(startDir, 'node_modules');
+  await fs.mkdir(nm, { recursive: true });
+  return nm;
+}
+
+async function installPackageFromDist({ packageName, distDir, appRoot, log }) {
+  const nmRoot = await resolveNodeModulesRoot(appRoot);
+  const { scope, name } = splitPackageName(packageName);
+  const pkgDir = scope ? path.join(nmRoot, scope, name) : path.join(nmRoot, name);
+
+  log?.step?.(`installation locale dans node_modules (${scope ? `${scope}/${name}` : name})`);
+
+  await fs.rm(pkgDir, { recursive: true, force: true });
+  await fs.mkdir(path.dirname(pkgDir), { recursive: true });
+
+  await fs.cp(distDir, pkgDir, {
+    recursive: true,
+    filter: (src) => !src.endsWith('.tgz'),
+  });
+
+  return pkgDir;
+}
+
+export async function runDev(packageName, opts) {
+  const startCwd = process.cwd();
+  const debug = !!opts.debug;
+  const log = createLogger({ debug });
+
+  const useSandboxDefaults = packageName === undefined;
+  const appRoot = useSandboxDefaults ? await resolveSandboxAppRoot(startCwd) : await resolveDevAppRoot(startCwd);
+
+  const effectivePackageName = packageName ?? '@obsidiane/bridge-sandbox';
+  const libName = deriveLibName(effectivePackageName);
+
+  const noModels = opts.models === false;
+  const preset = normalizePreset(useSandboxDefaults ? (opts.preset ?? 'native') : opts.preset);
+  const include = splitListArgs(opts.include);
+  const exclude = splitListArgs(opts.exclude);
+
+  const version = '0.0.0-dev';
+  const requiredMode = 'all-optional';
+  const specSource = useSandboxDefaults ? (opts.spec ?? 'http://localhost:8000/api/docs.json') : opts.spec;
+
+  log.title('dev — build standalone + install local');
+  log.info(`app: ${appRoot}`);
+  log.info(`package: ${effectivePackageName}@${version}`);
+  log.info(`lib: ${libName}`);
+  if (useSandboxDefaults) log.info('defaults sandbox appliqués');
+  if (noModels) log.info('models: désactivés (--no-models)');
+  else log.info(`spec: ${specSource} | preset: ${preset}`);
+
+  const { workspaceRoot, distRoot, npmCacheDir, requireFromWs } = await ensureStandaloneWorkspace({ repoRoot: appRoot, log });
+  log.info(`workspace: ${workspaceRoot}`);
+
+  let spec;
+  if (!noModels) {
+    log.step('lecture de la spec OpenAPI');
+    spec = await readOpenApiSpec(specSource);
+    log.success('spec chargée');
+  }
+
+  await ensureToolchainInstalled({ workspaceRoot, requireFromWs, npmCacheDir, log });
+
+  await generateBridgeWorkspace({
+    cwd: workspaceRoot,
+    libName,
+    packageName: effectivePackageName,
+    version,
+    noModels,
+    spec,
+    requiredMode,
+    preset,
+    include,
+    exclude,
+    debug,
+    log,
+    distRoot,
+  });
+
+  const ngPackageJsonPath = path.join(workspaceRoot, 'projects', libName, 'ng-package.json');
+  const tsconfigDevPath = path.join(workspaceRoot, 'projects', libName, 'tsconfig.lib.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', tsconfigDevPath], {
+    cwd: workspaceRoot,
+  });
+  if (packagrCode !== 0) process.exit(packagrCode);
+
+  const distDir = path.join(distRoot, libName);
+  log.step(`npm pack (${path.relative(appRoot, 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) process.exit(packCode);
+
+  await findLatestTgz(distDir); // keep producing the tgz in dist for inspection/use
+  await installPackageFromDist({ packageName: effectivePackageName, distDir, appRoot, log });
+
+  log.success('bridge installé (node_modules) ✅');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  throw new Error('This module is not meant to be executed directly.');
+}

package/tools/generator/models/handlebars.js

@@ -2,13 +2,19 @@ import fs from 'node:fs/promises';
 import * as path from 'node:path';
 import Handlebars from 'handlebars';
 
+const templateCache = new Map();
+
 /**
  * Rend un template Handlebars avec un contexte et écrit le fichier.
  * @param {{ templatePath: string, outPath: string, ctx: any }} params
  */
 export async function renderTemplateToFile({templatePath, outPath, ctx}) {
-  const tplSrc = await fs.readFile(templatePath, 'utf8');
-  const tpl = Handlebars.compile(tplSrc, {noEscape: true});
+  let tpl = templateCache.get(templatePath);
+  if (!tpl) {
+    const tplSrc = await fs.readFile(templatePath, 'utf8');
+    tpl = Handlebars.compile(tplSrc, {noEscape: true});
+    templateCache.set(templatePath, tpl);
+  }
   const out = tpl(ctx);
   await fs.mkdir(path.dirname(outPath), {recursive: true});
   await fs.writeFile(outPath, out, 'utf8');

package/tools/generator/models/naming.js

@@ -1,20 +1,26 @@
 /**
- * Convertit un nom de schéma OpenAPI en un nom lisible (sans artefacts jsonld/jsonapi)
- * et intégrant les groupes (ex: Identity.jsonld-user.read -> Identity user read)
+ * Construit un label "tokenisé" (sans `.` ni `-`) à partir d'un nom de schéma OpenAPI.
+ * Le label est ensuite passé à `sanitizeTypeName()` pour produire un identifiant TS stable.
+ *
  * @param {string} original
+ * @param {{ preset: 'all'|'native' }} cfg
  */
-export function friendlyName(original) {
-  const m = original.match(/^(.*?)(?:\.(?:jsonld|jsonapi))?-(.+)$/i);
-  if (m) {
-    const base = m[1];
-    const baseSimple = base.split('.').pop();
-    const groupTokens = m[2].split('.');
-    if (groupTokens.length && groupTokens[0].toLowerCase() === String(baseSimple).toLowerCase()) {
-      groupTokens.shift();
-    }
-    const group = groupTokens.join(' ');
-    return group ? `${base} ${group}` : base;
+export function schemaLabel(original, cfg) {
+  const preset = cfg?.preset ?? 'all';
+  if (preset === 'native') {
+    // En native, on vise un nom "entity-like" : on ignore le groupe (après `-`) si présent.
+    // Les variantes .jsonld/.jsonapi/jsonMergePatch sont censées être filtrées par le preset.
+    return String(original).split('-')[0];
   }
-  return original.replace(/\.(jsonld|jsonapi)$/ig, '');
-}
 
+  // En all, on encode tout : `.` et `-` deviennent des séparateurs de tokens.
+  const rawTokens = String(original).split(/[.-]/g).filter(Boolean);
+  const tokens = rawTokens.map((t) => {
+    const lower = t.toLowerCase();
+    if (lower === 'jsonld') return 'Jsonld';
+    if (lower === 'jsonapi') return 'Jsonapi';
+    if (lower === 'jsonmergepatch' || t === 'jsonMergePatch') return 'JsonMergePatch';
+    return t;
+  });
+  return tokens.join(' ');
+}

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

@@ -1,13 +1,11 @@
 import { sanitizeTypeName, quoteKeyIfNeeded } from './utils.js';
-import { filterSchemaNames, applySchemaNameFilters, mergeAllOf, isObject } from './schema-utils.js';
-import { friendlyName } from './naming.js';
+import { filterSchemaNames, applySchemaNameFilters, mergeAllOf, isObject, schemaNameFromRef } from './schema-utils.js';
+import { schemaLabel } 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)>,
@@ -18,40 +16,37 @@ import { tsTypeOf, withNullable } from './type-resolver.js';
  * Construit une map originalName -> sanitizedName, en assurant l’unicité
  * @param {string[]} schemaNames
  */
-function buildNameMap(schemaNames) {
-  const parse = (original) => {
-    const m = original.match(/^(.*?)(?:\.(?:jsonld|jsonapi))?-(.+)$/i);
-    return m ? { base: m[1], group: m[2] } : { base: original, group: null };
-  };
-
-  const parsed = schemaNames.map((n) => ({ name: n, ...parse(n) }));
-  const roots = parsed.filter((p) => !p.group);
-  const grouped = parsed.filter((p) => !!p.group);
-
-  // Root sanitized names (to avoid collisions when dropping group)
-  const rootSanitized = new Set(roots.map((p) => sanitizeTypeName(p.base, new Set())));
-
-  // Count base candidates among grouped to see if unique
-  const baseCount = new Map();
-  for (const p of grouped) {
-    const cand = sanitizeTypeName(p.base, new Set());
-    baseCount.set(cand, (baseCount.get(cand) || 0) + 1);
-  }
+function normalizeNativeBase(original) {
+  return String(original)
+    .replace(/\.jsonld\b/ig, '')
+    .replace(/\.jsonapi\b/ig, '')
+    .replace(/\.jsonmergepatch\b/ig, '')
+    .split('-')[0];
+}
 
-  // Build final map with uniqueness
+function buildNameMap(schemaNames, schemas, preset) {
+  // Build final map with uniqueness (deterministic order)
   const used = new Set();
   const nameMap = new Map();
-  for (const p of parsed) {
-    let label;
-    if (p.group) {
-      const cand = sanitizeTypeName(p.base, new Set());
-      const isUniqueBase = (baseCount.get(cand) === 1) && !rootSanitized.has(cand);
-      label = isUniqueBase ? p.base : friendlyName(p.name);
-    } else {
-      label = friendlyName(p.name);
+  for (const original of schemaNames) {
+    const label = schemaLabel(original, {preset});
+    nameMap.set(original, sanitizeTypeName(label, used));
+  }
+
+  // In native mode, alias excluded variants to the selected base type
+  // so `$ref` doesn't leak "User-user.write" etc into generated types.
+  if (preset === 'native') {
+    const baseToSanitized = new Map();
+    for (const original of schemaNames) {
+      baseToSanitized.set(normalizeNativeBase(original), nameMap.get(original));
+    }
+    for (const original of Object.keys(schemas)) {
+      const base = normalizeNativeBase(original);
+      const sanitized = baseToSanitized.get(base);
+      if (sanitized) nameMap.set(original, sanitized);
     }
-    nameMap.set(p.name, sanitizeTypeName(label, used));
   }
+
   return nameMap;
 }
 
@@ -65,7 +60,8 @@ export function buildModelsFromOpenAPI(spec, options) {
   const opts = { requiredMode: 'all-optional', ...(options || {}) };
   const schemas = spec?.components?.schemas || {};
   const schemaNames = applySchemaNameFilters(filterSchemaNames(schemas, opts), opts);
-  const nameMap = buildNameMap(schemaNames);
+  const preset = opts.preset ?? 'all';
+  const nameMap = buildNameMap(schemaNames, schemas, preset);
   const allSanitizedNames = new Set([...nameMap.values()]);
 
   /** @type {ModelDefinition[]} */
@@ -73,19 +69,49 @@ export function buildModelsFromOpenAPI(spec, options) {
 
   for (const originalName of schemaNames) {
     const raw = schemas[originalName];
+    const sanitized = nameMap.get(originalName);
+    if (!sanitized) continue;
+
+    /** @type {string[]} */
+    const extendsTypes = [];
+
     let effective = raw;
     if (raw?.allOf) {
-      const merged = mergeAllOf(raw.allOf, opts);
-      if (merged) effective = merged;
+      const merged = mergeAllOf(raw.allOf);
+      if (merged) {
+        effective = merged;
+      } else {
+        // Non-flattenable allOf (refs, mixed forms): keep inline object props and model refs as extends.
+        const props = {};
+        const required = new Set();
+        const ext = new Set();
+
+        for (const part of raw.allOf) {
+          if (part?.$ref) {
+            const orig = schemaNameFromRef(part.$ref);
+            const refName = orig ? nameMap.get(orig) : undefined;
+            if (refName && refName !== sanitized && allSanitizedNames.has(refName)) ext.add(refName);
+            continue;
+          }
+          const isObj = part?.type === 'object' || isObject(part?.properties);
+          if (!isObj) continue;
+          Object.assign(props, part.properties || {});
+          for (const r of part.required || []) required.add(r);
+        }
+
+        extendsTypes.push(...[...ext].sort((a, b) => a.localeCompare(b)));
+        effective = { type: 'object', properties: props, required: [...required] };
+      }
     }
 
-    const isObjectLike = effective?.type === 'object' || isObject(effective?.properties);
+    const isObjectLike = effective?.type === 'object' || isObject(effective?.properties) || extendsTypes.length > 0;
     if (!isObjectLike) continue;
 
-    const sanitized = nameMap.get(originalName);
     const required = new Set(effective.required || []);
     const deps = new Set();
 
+    for (const e of extendsTypes) deps.add(e);
+
     const props = Object.entries(effective.properties || {}).map(([propName, prop]) => {
       const baseType = tsTypeOf(prop, deps, nameMap);
       const type = withNullable(baseType, prop);
@@ -102,7 +128,7 @@ export function buildModelsFromOpenAPI(spec, options) {
       .filter((n) => allSanitizedNames.has(n))
       .sort((a, b) => a.localeCompare(b));
 
-    models.push({name: sanitized, props, imports});
+    models.push({name: sanitized, props, imports, extendsTypes});
   }
 
   return {models};