@zohofinance/commerce 2.0.0 → 2.2.0

package/ts-dist/utils/theme-validation.js

@@ -1,34 +1,21 @@
 import fs from 'fs-extra';
 import path from 'path';
+import chalk from 'chalk';
 import jsonlint from 'jsonlint-mod';
+import { validateLiquidReferences, validateLiquidSchemas, validateTemplateJson, validateThemeSettingsFiles } from './template-reference-validation.js';
+/** Default object keys required for structured setting types. */
 export const SETTING_RULES = {
     select: ['display_name', 'value'],
-    collection: ['display_name', 'handle'],
-    category: ['display_name', 'handle'],
+    radio: ['display_name', 'value'],
+    url: ['display_name', 'handle'],
+    collection: ['handle'],
+    category: ['handle'],
     menu: ['display_name', 'handle'],
-    blog: ['display_name', 'handle'],
-    product: ['display_name', 'handle']
+    blog: ['handle'],
+    product: ['handle'],
+    image_picker: ['url'],
+    media_picker: ['url']
 };
-const SUPPORTED_SETTING_TYPES = new Set([
-    'text',
-    'textarea',
-    'richtext',
-    'checkbox',
-    'range',
-    'select',
-    'radio',
-    'media_picker',
-    'preview_layout',
-    'color',
-    'image_picker',
-    'url',
-    'header',
-    'category',
-    'collection',
-    'blog',
-    'menu',
-    'product'
-]);
 const SKIP_DIRS = new Set([
     'node_modules',
     'ts-dist',
@@ -142,114 +129,6 @@ async function validateJsonFiles(folder, cwd, issues) {
         }
     }
 }
-function validateSettings(settings, file) {
-    const issues = [];
-    for (const setting of settings) {
-        const settingType = String(setting.type ?? '');
-        if (!settingType) {
-            issues.push({
-                category: 'schema',
-                message: 'Setting is missing required "type" field',
-                file
-            });
-            continue;
-        }
-        if (!SUPPORTED_SETTING_TYPES.has(settingType)) {
-            issues.push({
-                category: 'schema',
-                message: `Unsupported setting type "${settingType}"`,
-                file
-            });
-            continue;
-        }
-        if (settingType !== 'header') {
-            const id = String(setting.id ?? '');
-            if (!id) {
-                issues.push({
-                    category: 'schema',
-                    message: `Setting of type "${settingType}" is missing required "id" field`,
-                    file
-                });
-                continue;
-            }
-        }
-        const requiredKeys = SETTING_RULES[settingType];
-        if (!requiredKeys) {
-            continue;
-        }
-        const settingId = String(setting.id ?? '');
-        const settingDefault = setting.default;
-        if (typeof settingDefault !== 'object' || settingDefault === null) {
-            issues.push({
-                category: 'schema',
-                message: `Setting id "${settingId}" (type "${settingType}"): ` +
-                    `'default' must be an object with keys ${requiredKeys.join(', ')}, ` +
-                    `found ${JSON.stringify(settingDefault)}`,
-                file
-            });
-            continue;
-        }
-        const defaultObj = settingDefault;
-        const missing = requiredKeys.filter((key) => !(key in defaultObj));
-        if (missing.length > 0) {
-            issues.push({
-                category: 'schema',
-                message: `Setting id "${settingId}" (type "${settingType}"): ` +
-                    `missing default keys ${missing.join(', ')}, found ${JSON.stringify(settingDefault)}`,
-                file
-            });
-        }
-    }
-    return issues;
-}
-function processSchema(schemaJson, file) {
-    const issues = [];
-    if (Array.isArray(schemaJson.settings)) {
-        issues.push(...validateSettings(schemaJson.settings, file));
-    }
-    if (Array.isArray(schemaJson.blocks)) {
-        for (const block of schemaJson.blocks) {
-            if (Array.isArray(block.settings)) {
-                issues.push(...validateSettings(block.settings, file));
-            }
-        }
-    }
-    return issues;
-}
-function validateLiquidFiles(cwd) {
-    const issues = [];
-    for (const folder of ['sections', 'blocks']) {
-        const dir = path.join(cwd, folder);
-        if (!fs.existsSync(dir)) {
-            continue;
-        }
-        const files = fs
-            .readdirSync(dir)
-            .filter((file) => file.endsWith('.liquid'));
-        for (const file of files) {
-            const filePath = path.join(dir, file);
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const schemaMatch = content.match(/{% schema %}([\s\S]*?){% endschema %}/);
-            if (!schemaMatch) {
-                continue;
-            }
-            let schemaJson;
-            try {
-                schemaJson = JSON.parse(schemaMatch[1].trim());
-            }
-            catch (err) {
-                issues.push({
-                    category: 'schema',
-                    message: `Invalid schema JSON: ${err.message}`,
-                    file: path.relative(cwd, filePath)
-                });
-                continue;
-            }
-            issues.push(...processSchema(schemaJson, path.relative(cwd, filePath)));
-        }
-    }
-    return issues;
-}
 function validateAssetFileSizes(cwd) {
     const issues = [];
     const assetsDir = path.join(cwd, 'assets');
@@ -272,9 +151,11 @@ function validateAssetFileSizes(cwd) {
 const REQUIRED_FILES_COMMON = [
     { file: 'layouts/theme.liquid', description: 'main layout file' },
     { file: 'i18n/en.json', description: 'default translation fallback' },
-    { file: 'i18n/en.schema.json', description: 'schema label translations' }
+    { file: 'i18n/en.schema.json', description: 'schema label translations' },
+    { file: 'settings/schema.json', description: 'theme settings schema' },
+    { file: 'settings/theme.json', description: 'theme settings data' }
 ];
-function validateRequiredFiles(cwd, _mode) {
+function validateRequiredFiles(cwd) {
     const requiredFiles = REQUIRED_FILES_COMMON;
     return requiredFiles
         .filter(({ file }) => !fs.existsSync(path.join(cwd, file)))
@@ -286,19 +167,53 @@ function validateRequiredFiles(cwd, _mode) {
 }
 export async function validateTheme(cwd = process.cwd(), options = {}) {
     const mode = options.mode ?? 'build';
+    // Dev and build share one rule set. A section missing available_in or a
+    // named preset is logged in dev and blocks the zip on build.
+    if (mode !== 'dev' && mode !== 'build') {
+        return { valid: true, issues: [] };
+    }
     const issues = [
-        ...validateRequiredFiles(cwd, mode),
+        ...validateRequiredFiles(cwd),
         ...validateTranslationKeys(cwd),
         ...validateAssetFileSizes(cwd),
-        ...validateLiquidFiles(cwd)
+        ...validateLiquidSchemas(cwd, mode),
+        ...validateThemeSettingsFiles(cwd),
+        ...validateTemplateJson(cwd),
+        ...validateLiquidReferences(cwd)
     ];
     await validateJsonFiles(cwd, cwd, issues);
+    const errors = validationErrors(issues);
     return {
-        valid: issues.length === 0,
+        valid: errors.length === 0,
         issues
     };
 }
+export function validationErrors(issues) {
+    return issues.filter((issue) => (issue.severity ?? 'error') === 'error');
+}
+export function validationWarnings(issues) {
+    return issues.filter((issue) => issue.severity === 'warning');
+}
 export function formatValidationIssuesForConsole(issues) {
+    const errors = validationErrors(issues);
+    const warnings = validationWarnings(issues);
+    const lines = [];
+    if (errors.length > 0) {
+        lines.push(formatIssueGroup(errors, '❌', chalk.red));
+    }
+    if (warnings.length > 0) {
+        const failing = warnings.filter((issue) => issue.failsBuild);
+        const plain = warnings.filter((issue) => !issue.failsBuild);
+        if (plain.length > 0) {
+            lines.push(formatIssueGroup(plain, '⚠️ ', chalk.yellow, 'These do not block preview or build. The storefront still renders the theme.'));
+        }
+        if (failing.length > 0) {
+            lines.push(formatIssueGroup(failing, '⚠️ ', chalk.red, 'These do not block preview, but they WILL CAUSE A BUILD ERROR. Fix them before building.'));
+        }
+    }
+    return lines.join('\n');
+}
+function formatIssueGroup(issues, mark, color, intro) {
     const grouped = new Map();
     for (const issue of issues) {
         const list = grouped.get(issue.category) ?? [];
@@ -308,16 +223,41 @@ export function formatValidationIssuesForConsole(issues) {
     const labels = {
         translation: 'Missing translation keys',
         json: 'Invalid JSON files',
-        schema: 'Invalid section/block schema settings',
+        schema: 'Invalid section/block schemas',
+        page: 'Invalid page or section-group JSON',
+        liquid: 'Liquid references the engine cannot render',
+        theme_settings: 'Invalid theme settings',
         asset_size: 'Oversized assets',
         required_file: 'Missing required files'
     };
     const lines = [];
+    if (intro) {
+        lines.push(color(`\n${intro}`));
+    }
     for (const [category, categoryIssues] of grouped) {
-        lines.push(`\n❌ ${labels[category]}:`);
+        lines.push(color(chalk.bold(`\n${mark} ${labels[category]}`) +
+            ` (${categoryIssues.length})`));
+        // Group identical problems (ignoring array indices) so each is stated once.
+        const byMessage = new Map();
         for (const issue of categoryIssues) {
-            const location = issue.file ? ` (${issue.file})` : '';
-            lines.push(`  • ${issue.message}${location}`);
+            const key = issue.message.replace(/\[\d+\]/g, '[]');
+            const where = issue.message.match(/^(\S*\[\d+\]\S*)\s/)?.[1];
+            const list = byMessage.get(key) ?? [];
+            if (!list.some((e) => e.file === issue.file && e.where === where)) {
+                list.push({ file: issue.file, where });
+            }
+            byMessage.set(key, list);
+        }
+        for (const [message, entries] of byMessage) {
+            const withFiles = entries.filter((e) => e.file);
+            const count = withFiles.length > 0
+                ? chalk.dim(` — ${withFiles.length} file${withFiles.length === 1 ? '' : 's'}`)
+                : '';
+            lines.push(color(`  ▸ ${message}`) + count);
+            for (const entry of withFiles) {
+                const where = entry.where ? chalk.dim(`  ${entry.where}`) : '';
+                lines.push(color(`      – ${entry.file}`) + where);
+            }
         }
     }
     return lines.join('\n');
@@ -326,6 +266,7 @@ export function assertThemeValid(result) {
     if (result.valid) {
         return;
     }
-    const formatted = formatValidationIssuesForConsole(result.issues);
-    throw new Error(`Build aborted: theme validation failed.${formatted}`);
+    // Callers print the issue list themselves; keep the message short so it isn't repeated.
+    const count = validationErrors(result.issues).length;
+    throw new Error(`Build aborted: theme validation failed with ${count} error${count === 1 ? '' : 's'}.`);
 }