@wix/web50-cli 0.1.0 → 0.1.2

package/dist/esm/commands/validate.js

@@ -1,18 +1,19 @@
 import { Command } from 'commander';
 import Ajv from 'ajv/dist/2020';
 import { load as yamlLoad } from 'js-yaml';
-import { readFileSync, existsSync, readdirSync } from 'fs';
+import { readFileSync, existsSync, readdirSync, watch as fsWatch } from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
 import { error, info } from '../utils/print';
 import { cmsSchemaSchemaTemplate } from '../templates/cmsSchemaSchema';
+import { cmsMappingSchemaTemplate } from '../templates/cmsMappingSchema';
 import { aiInstructionsSchemaTemplate } from '../templates/aiInstructionsSchema';
 import { actionYamlSchemaTemplate } from '../templates/actionYamlSchema';
-
 // ── Bundled schemas (never exposed to user's project) ────────────────────────
 
 const SCHEMAS = {
   'cms-schema.yaml': yamlLoad(cmsSchemaSchemaTemplate()),
+  'cms-mapping.yaml': yamlLoad(cmsMappingSchemaTemplate()),
   'prompt-instructions.yaml': yamlLoad(aiInstructionsSchemaTemplate()),
   'action.yaml': yamlLoad(actionYamlSchemaTemplate())
 };
@@ -293,6 +294,91 @@ function buildCmsSchemaDomain(root) {
     }]
   };
 }
+function buildCmsMappingDomain(root) {
+  const filePath = path.join(root, 'src', 'configuration', 'cms', 'cms-mapping.yaml');
+  const fileName = 'cms-mapping.yaml';
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false
+  });
+  const schema = SCHEMAS[fileName];
+  let parsed;
+  let fileExists = false;
+  let yamlOk = false;
+  return {
+    name: 'CMS Mapping',
+    checks: [{
+      label: `${fileName} — file exists`,
+      run() {
+        fileExists = existsSync(filePath);
+        if (fileExists) {
+          return {
+            ok: true,
+            errors: []
+          };
+        }
+        return {
+          ok: false,
+          errors: [{
+            message: `File not found: ${filePath}`,
+            fix: `Create 'src/configuration/cms/cms-mapping.yaml' in your project.`
+          }]
+        };
+      }
+    }, {
+      label: `${fileName} — valid YAML`,
+      run() {
+        if (!fileExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — file does not exist'
+            }]
+          };
+        }
+        const result = tryParseYaml(filePath);
+        if (result.err !== undefined) {
+          return {
+            ok: false,
+            errors: [{
+              message: result.err,
+              fix: 'Fix the YAML syntax error above.'
+            }]
+          };
+        }
+        parsed = result.data;
+        yamlOk = true;
+        return {
+          ok: true,
+          errors: []
+        };
+      }
+    }, {
+      label: `${fileName} — schema valid`,
+      run() {
+        if (!yamlOk) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — YAML parse failed'
+            }]
+          };
+        }
+        const validate = ajv.compile(schema);
+        if (validate(parsed)) {
+          return {
+            ok: true,
+            errors: []
+          };
+        }
+        return {
+          ok: false,
+          errors: (validate.errors ?? []).map(e => formatAjvError(e))
+        };
+      }
+    }]
+  };
+}
 function buildActionsDomain(root) {
   const actionsDir = path.join(root, 'src', 'actions');
   const registryPath = path.join(root, 'src', 'createRegistry.ts');
@@ -666,27 +752,278 @@ function buildActionsDomain(root) {
   };
 }
 
-// ── Command ───────────────────────────────────────────────────────────────────
+// ── Sections helpers ──────────────────────────────────────────────────────────
 
-export const validateCommand = new Command('validate').description('Validate project config files against their schemas').action(() => {
-  const root = findProjectRoot(process.cwd());
-  if (!root) {
-    error('No web5.config.json found — run this command from inside a Web5 project');
-    process.exit(1);
+/**
+ * Extracts the text of every `.register(...)` call that has a component array.
+ * Uses bracket-counting to handle nesting correctly.
+ * Skips system registrations that have no `[` (e.g. SkipNodesSectionDefinition).
+ */
+function extractRegisterBlocks(content) {
+  const blocks = [];
+  const marker = '.register(';
+  let searchFrom = 0;
+  let start = content.indexOf(marker, searchFrom);
+  while (start !== -1) {
+    let depth = 0;
+    let i = start + marker.length - 1; // position of the opening '('
+    while (i < content.length) {
+      const ch = content[i];
+      if (ch === '(') {
+        depth++;
+      } else if (ch === ')') {
+        depth--;
+        if (depth === 0) {
+          break;
+        }
+      }
+      i++;
+    }
+    const block = content.slice(start, i + 1);
+    if (block.includes('[')) {
+      blocks.push(block);
+    }
+    searchFrom = i + 1;
+    start = content.indexOf(marker, searchFrom);
   }
-  info(`Project root: ${root}`);
-  console.log('');
-  const domains = [buildAiInstructionsDomain(root), buildCmsSchemaDomain(root), buildActionsDomain(root)];
-  let hasErrors = false;
-  for (const domain of domains) {
+  return blocks;
+}
+
+/**
+ * Scans all import lines that reference a `sections/` path and returns a
+ * Map<localName, stem>.  Handles aliases and multi-name imports:
+ *   import { KpiSection as KpiSectionComponent } from '...sections/KpiSection'
+ *   → "KpiSectionComponent" → "KpiSection"
+ */
+function buildSectionImportMap(content) {
+  const map = new Map();
+  const re = /import\s*\{([^}]+)\}\s*from\s*['"][^'"]*sections\/(\w+)['"]/g;
+  let m = re.exec(content);
+  while (m !== null) {
+    const stem = m[2];
+    const names = m[1].split(',');
+    for (const raw of names) {
+      const token = raw.trim();
+      if (!token) {
+        continue;
+      }
+      const asParts = token.split(/\s+as\s+/);
+      const localName = (asParts[1] ?? asParts[0]).trim();
+      if (localName) {
+        map.set(localName, stem);
+      }
+    }
+    m = re.exec(content);
+  }
+  return map;
+}
+
+// ── Sections domain ────────────────────────────────────────────────────────────
+
+function buildSectionsDomain(root) {
+  const registryPath = path.join(root, 'src', 'createRegistry.ts');
+  const sectionsDir = path.join(root, 'src', 'components', 'sections');
+  let registryExists = false;
+  let registryContent = '';
+  let tsxFiles = [];
+  return {
+    name: 'Sections',
+    checks: [
+    // ── Check 1: createRegistry.ts exists ────────────────────────────────
+    {
+      label: 'createRegistry.ts — file exists',
+      run() {
+        registryExists = existsSync(registryPath);
+        if (!registryExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'src/createRegistry.ts not found',
+              fix: 'Create src/createRegistry.ts and export a createRegistry() function that registers your section components.'
+            }]
+          };
+        }
+        registryContent = readText(registryPath);
+        tsxFiles = existsSync(sectionsDir) ? readdirSync(sectionsDir).filter(f => f.endsWith('.tsx')) : [];
+        return {
+          ok: true,
+          errors: []
+        };
+      }
+    },
+    // ── Check 2: all .tsx files imported in createRegistry.ts ─────────────
+    {
+      label: 'src/components/sections/ — all .tsx files imported in createRegistry.ts',
+      run() {
+        if (!registryExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — createRegistry.ts not found'
+            }]
+          };
+        }
+        const errors = [];
+        for (const file of tsxFiles) {
+          const stem = path.basename(file, '.tsx');
+          if (!registryContent.includes(`sections/${stem}`)) {
+            errors.push({
+              message: `'${stem}.tsx' is not imported in src/createRegistry.ts`,
+              fix: `Add: import { ${stem} } from './components/sections/${stem}';`
+            });
+          }
+        }
+        return errors.length === 0 ? {
+          ok: true,
+          errors: []
+        } : {
+          ok: false,
+          errors
+        };
+      }
+    },
+    // ── Check 3: all .tsx files wired into a .register() call ─────────────
+    {
+      label: 'src/components/sections/ — all .tsx files wired into .register()',
+      run() {
+        if (!registryExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — createRegistry.ts not found'
+            }]
+          };
+        }
+        const importMap = buildSectionImportMap(registryContent);
+        const blocks = extractRegisterBlocks(registryContent);
+        const blockText = blocks.join('\n');
+        const errors = [];
+        for (const file of tsxFiles) {
+          var _find;
+          const stem = path.basename(file, '.tsx');
+          // Find the local name for this stem (may have been aliased on import)
+          const localName = ((_find = [...importMap.entries()].find(_ref => {
+            let [, s] = _ref;
+            return s === stem;
+          })) == null ? void 0 : _find[0]) ?? stem;
+          if (!blockText.includes(localName)) {
+            errors.push({
+              message: `'${localName}' (${stem}.tsx) is imported but not passed to any .register() call`,
+              fix: `Add { component: ${localName} } inside a .register(new <Definition>(), [...]) call in src/createRegistry.ts.`
+            });
+          }
+        }
+        return errors.length === 0 ? {
+          ok: true,
+          errors: []
+        } : {
+          ok: false,
+          errors
+        };
+      }
+    },
+    // ── Check 4: every .register() block has a catch-all entry ────────────
+    {
+      label: 'createRegistry.ts — all .register() blocks have a catch-all component',
+      run() {
+        if (!registryExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — createRegistry.ts not found'
+            }]
+          };
+        }
+        const blocks = extractRegisterBlocks(registryContent);
+        const errors = [];
+        for (const block of blocks) {
+          const defMatch = block.match(/\.register\(\s*new\s+(\w+)/);
+          const defName = defMatch ? defMatch[1] : '(unknown)';
+
+          // Split on "{ component:" to isolate each entry
+          const entries = block.split('{ component:').slice(1);
+          if (entries.length === 0) {
+            continue;
+          }
+          const allHaveIntent = entries.every(entry => entry.includes('intent:'));
+          if (allHaveIntent) {
+            errors.push({
+              message: `'${defName}' has no catch-all component — every entry specifies an intent`,
+              fix: `Add a catch-all entry to the .register(new ${defName}(), [...]) call:\n       { component: YourDefaultComponent }`
+            });
+          }
+        }
+        return errors.length === 0 ? {
+          ok: true,
+          errors: []
+        } : {
+          ok: false,
+          errors
+        };
+      }
+    },
+    // ── Check 5: all component refs in .register() resolve to a .tsx file ─
+    {
+      label: 'createRegistry.ts — all .register() component references resolve to a .tsx file',
+      run() {
+        if (!registryExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — createRegistry.ts not found'
+            }]
+          };
+        }
+        const importMap = buildSectionImportMap(registryContent);
+        const blocks = extractRegisterBlocks(registryContent);
+        const errors = [];
+        for (const block of blocks) {
+          const refs = [...block.matchAll(/\{\s*component:\s*(\w+)/g)].map(m => m[1]);
+          for (const ref of refs) {
+            const stem = importMap.get(ref);
+            if (stem === undefined) {
+              errors.push({
+                message: `Component '${ref}' used in .register() has no matching import from sections/`,
+                fix: `Add: import { ${ref} } from './components/sections/${ref}'; or check the import alias.`
+              });
+              continue;
+            }
+            const filePath = path.join(sectionsDir, `${stem}.tsx`);
+            if (!existsSync(filePath)) {
+              errors.push({
+                message: `Component '${ref}' maps to '${stem}.tsx' which does not exist in src/components/sections/`,
+                fix: `Create src/components/sections/${stem}.tsx, or remove the stale .register() entry from src/createRegistry.ts.`
+              });
+            }
+          }
+        }
+        return errors.length === 0 ? {
+          ok: true,
+          errors: []
+        } : {
+          ok: false,
+          errors
+        };
+      }
+    }]
+  };
+}
+
+// ── Rendering ─────────────────────────────────────────────────────────────────
+
+function printDomain(domain, results, verbose) {
+  const failed = results.filter(r => !r.result.ok);
+  const domainOk = failed.length === 0;
+  if (verbose) {
     console.log(domain.name);
-    for (const check of domain.checks) {
-      const result = check.run();
+    for (const {
+      label,
+      result
+    } of results) {
       if (result.ok) {
-        console.log(chalk.green(`  \u2714  ${check.label}`));
+        console.log(chalk.green(`  \u2714  ${label}`));
       } else {
-        hasErrors = true;
-        process.stderr.write(chalk.red(`  \u2716  ${check.label}\n`));
+        process.stderr.write(chalk.red(`  \u2716  ${label}\n`));
         for (const e_ of result.errors) {
           process.stderr.write(`       ${e_.message}\n`);
           if (e_.fix) {
@@ -696,9 +1033,276 @@ export const validateCommand = new Command('validate').description('Validate pro
       }
     }
     console.log('');
+    return domainOk;
+  }
+
+  // Slim mode
+  if (domainOk) {
+    console.log(chalk.green(`\u2714  ${domain.name} — valid`));
+    return true;
+  }
+  console.log(domain.name);
+  for (const {
+    label,
+    result
+  } of failed) {
+    process.stderr.write(chalk.red(`  \u2716  ${label}\n`));
+    for (const e_ of result.errors) {
+      process.stderr.write(`       ${e_.message}\n`);
+      if (e_.fix) {
+        process.stderr.write(`       Fix: ${e_.fix}\n`);
+      }
+    }
+  }
+  console.log('');
+  return false;
+}
+
+// ── JSON output ───────────────────────────────────────────────────────────────
+
+function collectDomainJson(domain, results) {
+  return {
+    name: domain.name,
+    ok: results.every(r => r.result.ok),
+    checks: results.map(_ref2 => {
+      let {
+        label,
+        result
+      } = _ref2;
+      return {
+        label,
+        ok: result.ok,
+        errors: result.errors
+      };
+    })
+  };
+}
+
+// ── Build scripts domain ──────────────────────────────────────────────────────
+
+function buildScriptsDomain(root) {
+  const pkgPath = path.join(root, 'package.json');
+  let pkg = {};
+  let fileExists = false;
+  return {
+    name: 'Build Scripts',
+    checks: [{
+      label: 'package.json — file exists',
+      run() {
+        fileExists = existsSync(pkgPath);
+        if (!fileExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: `File not found: ${pkgPath}`,
+              fix: `Create a 'package.json' at the root of your project.`
+            }]
+          };
+        }
+        try {
+          pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        } catch (e) {
+          fileExists = false;
+          return {
+            ok: false,
+            errors: [{
+              message: `Failed to parse package.json: ${e instanceof Error ? e.message : String(e)}`,
+              fix: `Fix the JSON syntax in your package.json.`
+            }]
+          };
+        }
+        return {
+          ok: true,
+          errors: []
+        };
+      }
+    }, {
+      label: 'package.json — bundle script defined',
+      run() {
+        var _pkg$scripts;
+        if (!fileExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — package.json not readable'
+            }]
+          };
+        }
+        if (typeof ((_pkg$scripts = pkg.scripts) == null ? void 0 : _pkg$scripts.bundle) === 'string' && pkg.scripts.bundle.length > 0) {
+          return {
+            ok: true,
+            errors: []
+          };
+        }
+        return {
+          ok: false,
+          errors: [{
+            message: `Missing 'bundle' script in package.json`,
+            fix: `Add a 'bundle' script to your package.json scripts, e.g.:\n  "bundle": "vite build --config src/vite.cdn.config.ts"`
+          }]
+        };
+      }
+    }, {
+      label: 'package.json — build script defined',
+      run() {
+        var _pkg$scripts2;
+        if (!fileExists) {
+          return {
+            ok: false,
+            errors: [{
+              message: 'skipped — package.json not readable'
+            }]
+          };
+        }
+        if (typeof ((_pkg$scripts2 = pkg.scripts) == null ? void 0 : _pkg$scripts2.build) === 'string' && pkg.scripts.build.length > 0) {
+          return {
+            ok: true,
+            errors: []
+          };
+        }
+        return {
+          ok: false,
+          errors: [{
+            message: `Missing 'build' script in package.json`,
+            fix: `Add a 'build' script to your package.json scripts, e.g.:\n  "build": "tsc"`
+          }]
+        };
+      }
+    }]
+  };
+}
+
+// ── Domain selection ──────────────────────────────────────────────────────────
+
+const DOMAIN_NAME_MAP = {
+  ai: 'AI Instructions',
+  cms: 'CMS Schema',
+  'cms-mapping': 'CMS Mapping',
+  scripts: 'Build Scripts',
+  actions: 'Actions',
+  sections: 'Sections'
+};
+function selectDomains(root, filter) {
+  const all = [buildAiInstructionsDomain(root), buildCmsSchemaDomain(root), buildCmsMappingDomain(root), buildActionsDomain(root), buildScriptsDomain(root), buildSectionsDomain(root)];
+  if (!filter) {
+    return all;
   }
-  if (hasErrors) {
+  const filters = Array.isArray(filter) ? filter : [filter];
+  const names = new Set(filters.map(f => DOMAIN_NAME_MAP[f]));
+  return all.filter(d => names.has(d.name));
+}
+
+// ── Core runner ───────────────────────────────────────────────────────────────
+
+function runDomains(domains, verbose, format) {
+  let hasErrors = false;
+  const jsonResults = [];
+  for (const domain of domains) {
+    const results = domain.checks.map(check => ({
+      label: check.label,
+      result: check.run()
+    }));
+    let domainOk;
+    if (format === 'json') {
+      const jr = collectDomainJson(domain, results);
+      jsonResults.push(jr);
+      domainOk = jr.ok;
+    } else {
+      domainOk = printDomain(domain, results, verbose);
+    }
+    if (!domainOk) {
+      hasErrors = true;
+    }
+  }
+  return {
+    ok: !hasErrors,
+    jsonResults
+  };
+}
+
+// ── Programmatic API ─────────────────────────────────────────────────────────
+
+/**
+ * Runs validation domains against the given project root.
+ * Pass `filters` to validate only specific domains; omit to validate all.
+ * Prints results in slim mode and returns true if everything passes.
+ */
+export function runValidation(root, filters) {
+  const domains = selectDomains(root, filters);
+  const {
+    ok
+  } = runDomains(domains, false, 'text');
+  return ok;
+}
+
+// ── Watch mode ────────────────────────────────────────────────────────────────
+
+function startWatch(root, run) {
+  const watchDirs = [path.join(root, 'src', 'configuration'), path.join(root, 'src', 'actions'), path.join(root, 'src', 'components', 'sections'), path.join(root, 'src', 'createRegistry.ts')].filter(d => existsSync(d));
+  if (watchDirs.length === 0) {
+    error('No directories to watch found.');
+    return;
+  }
+  let debounce = null;
+  const trigger = () => {
+    if (debounce) {
+      clearTimeout(debounce);
+    }
+    debounce = setTimeout(() => {
+      console.clear();
+      info(`[${new Date().toLocaleTimeString()}] Re-validating...`);
+      console.log('');
+      run();
+    }, 200);
+  };
+  for (const dir of watchDirs) {
+    fsWatch(dir, {
+      recursive: true
+    }, trigger);
+  }
+  info(`Watching for changes in ${watchDirs.map(d => path.relative(root, d)).join(', ')}...`);
+  info('Press Ctrl+C to stop.');
+  console.log('');
+}
+
+// ── Command ───────────────────────────────────────────────────────────────────
+
+export const validateCommand = new Command('validate').description('Validate project config files against their schemas').option('--verbose', 'Show all checks, including passing ones').option('--domain <domain>', 'Only validate one domain: ai, cms, actions, scripts, or sections').option('--format <format>', 'Output format: text (default) or json', 'text').option('--watch', 'Re-validate on file changes (TTY only)').option('--strict', 'Exit with error even on warnings').option('--project <path>', 'Explicit project root (overrides cwd auto-detection)').action(opts => {
+  const verbose = Boolean(opts.verbose);
+  const format = opts.format ?? 'text';
+  const domainFilter = opts.domain;
+  const root = opts.project ? path.resolve(opts.project) : findProjectRoot(process.cwd());
+  if (!root) {
+    error('No web5.config.json found — run this command from inside a Web5 project');
     process.exit(1);
   }
+  if (format === 'text') {
+    info(`Project root: ${root}`);
+    console.log('');
+  }
+  const run = () => {
+    const domains = selectDomains(root, domainFilter);
+    const {
+      ok,
+      jsonResults
+    } = runDomains(domains, verbose, format);
+    if (format === 'json') {
+      console.log(JSON.stringify({
+        ok,
+        domains: jsonResults
+      }, null, 2));
+    }
+    if (!ok && !opts.watch) {
+      process.exit(1);
+    }
+  };
+  run();
+  if (opts.watch) {
+    if (!process.stdout.isTTY) {
+      error('--watch requires a TTY (interactive terminal).');
+      process.exit(1);
+    }
+    startWatch(root, run);
+  }
 });
 //# sourceMappingURL=validate.js.map