@wix/web50-cli 0.1.1 → 0.1.3

package/dist/esm/commands/validate.js

@@ -6,13 +6,14 @@ 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,6 +752,263 @@ function buildActionsDomain(root) {
   };
 }
 
+// ── Sections helpers ──────────────────────────────────────────────────────────
+
+/**
+ * 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);
+  }
+  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) {
@@ -721,11 +1064,11 @@ function collectDomainJson(domain, results) {
   return {
     name: domain.name,
     ok: results.every(r => r.result.ok),
-    checks: results.map(_ref => {
+    checks: results.map(_ref2 => {
       let {
         label,
         result
-      } = _ref;
+      } = _ref2;
       return {
         label,
         ok: result.ok,
@@ -831,16 +1174,22 @@ function buildScriptsDomain(root) {
 
 // ── 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), buildActionsDomain(root), buildScriptsDomain(root)];
-  if (!filter) return all;
-  const map = {
-    ai: 'AI Instructions',
-    cms: 'CMS Schema',
-    scripts: 'Build Scripts',
-    actions: 'Actions'
-  };
-  return all.filter(d => d.name === map[filter]);
+  const all = [buildAiInstructionsDomain(root), buildCmsSchemaDomain(root), buildCmsMappingDomain(root), buildActionsDomain(root), buildScriptsDomain(root), buildSectionsDomain(root)];
+  if (!filter) {
+    return all;
+  }
+  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 ───────────────────────────────────────────────────────────────
@@ -861,7 +1210,9 @@ function runDomains(domains, verbose, format) {
     } else {
       domainOk = printDomain(domain, results, verbose);
     }
-    if (!domainOk) hasErrors = true;
+    if (!domainOk) {
+      hasErrors = true;
+    }
   }
   return {
     ok: !hasErrors,
@@ -872,11 +1223,12 @@ function runDomains(domains, verbose, format) {
 // ── Programmatic API ─────────────────────────────────────────────────────────
 
 /**
- * Runs all validation domains against the given project root.
+ * 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) {
-  const domains = selectDomains(root);
+export function runValidation(root, filters) {
+  const domains = selectDomains(root, filters);
   const {
     ok
   } = runDomains(domains, false, 'text');
@@ -886,14 +1238,16 @@ export function runValidation(root) {
 // ── Watch mode ────────────────────────────────────────────────────────────────
 
 function startWatch(root, run) {
-  const watchDirs = [path.join(root, 'src', 'configuration'), path.join(root, 'src', 'actions')].filter(d => existsSync(d));
+  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);
+    if (debounce) {
+      clearTimeout(debounce);
+    }
     debounce = setTimeout(() => {
       console.clear();
       info(`[${new Date().toLocaleTimeString()}] Re-validating...`);
@@ -913,7 +1267,7 @@ function startWatch(root, run) {
 
 // ── 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, or scripts').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 => {
+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;