@madgex/fert 7.3.0 → 7.4.0

package/bin/commands/build.js

@@ -22,7 +22,7 @@ export async function build(options = {}) {
     throw Error(`Missing or invalid --target option. Choose from [${validTargets}]`);
   }
 
-  await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], {
+  await validation.runServiceValidators(validation.getAllValidators(), {
     fertConfig,
     throwable: true,
   });

package/bin/commands/dev-server.js

@@ -33,10 +33,14 @@ export async function createDevServer(options = {}) {
   const translationPath = path.resolve(fertConfig.workingDir, SERVICE_TRANSLATIONS_FILEPATH);
   // watch brand.json & translation.json - re-validate
   chokidar.watch([brandPath, translationPath], { ignoreInitial: true }).on('all', async () => {
-    await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], { fertConfig });
+    await validation.runServiceValidators(['brand-json', 'translations'], {
+      fertConfig,
+    });
+  });
+  // initial validation run (all validators on startup)
+  await validation.runServiceValidators(validation.getAllValidators(), {
+    fertConfig,
   });
-  // initial validation run
-  await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], { fertConfig });
 
   // building tokens
   await buildTokens(fertConfig);
@@ -50,6 +54,9 @@ export async function createDevServer(options = {}) {
   chokidar.watch([configPath, serviceConfigPath]).on('change', async () => {
     console.log('Config changed, reloading…');
     fertConfig = await resolveConfig(options);
+    await validation.runServiceValidators(['service-config'], {
+      fertConfig,
+    });
     await buildExternalAssets(fertConfig);
 
     // update server's config & tell Vite to refresh the page

package/bin/commands/publish.js

@@ -3,6 +3,7 @@ import * as Hoek from '@hapi/hoek';
 import chalk from 'chalk';
 import { resolveConfig } from '../utils/index.js';
 import { log } from '../utils/logging.js';
+import * as validation from '../utils/validation.js';
 import { getAwsParam } from './publish-tasks/get-aws-parameter.js';
 import { AssetStoreUploader } from './publish-tasks/asset-store-uploader.js';
 import { getCloudFrontDistributionsForDomain } from '../utils/lookup-cf-distribution-ids.js';
@@ -36,6 +37,11 @@ export async function publish(options) {
     throw Error(`Missing or invalid --target option. Choose from [${validTargets}]`);
   }
 
+  await validation.runServiceValidators(validation.getAllValidators(), {
+    fertConfig,
+    throwable: true,
+  });
+
   if (options.dryRun) {
     console.log(chalk.green('Running Publish in Dry Mode'));
   }

package/bin/commands/validate.js

@@ -15,7 +15,7 @@ export async function validateCommand(/* options */) {
   for (const { serviceConfig } of serviceConfigs) {
     const fertConfig = await resolveConfig({ serviceName: serviceConfig.serviceName });
 
-    await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], {
+    await validation.runServiceValidators(validation.getAllValidators(), {
       fertConfig,
       throwable: true,
     });

package/bin/utils/validation.js

@@ -1,11 +1,32 @@
 import chalk from 'chalk';
 import { log } from './logging.js';
+import * as validatorServiceConfig from '../validators/service-config.validator.js';
 import * as validatorBrandJson from '../validators/brand-json.validator.js';
 import * as validatorTranslations from '../validators/translations.validator.js';
 import * as validatorRedirectsCsv from '../validators/redirects-csv.validator.js';
+import * as validatorRequiredAssets from '../validators/required-assets.validator.js';
+import * as validatorCss from '../validators/css.validator.js';
+import * as validatorNavLinks from '../validators/nav-links.validator.js';
 
 /** @type {Array<Validator>} */
-const validators = [validatorBrandJson, validatorTranslations, validatorRedirectsCsv];
+const validators = [
+  validatorServiceConfig,
+  validatorBrandJson,
+  validatorTranslations,
+  validatorRedirectsCsv,
+  validatorRequiredAssets,
+  validatorCss,
+  validatorNavLinks,
+];
+
+/**
+ * Returns array of all validator names (derived from the validators registry).
+ * This is the canonical list - use this instead of maintaining a separate list.
+ * @returns {Array<string>}
+ */
+export function getAllValidators() {
+  return validators.map((v) => v.name);
+}
 
 /**
  *

package/bin/validators/css.validator.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as validation from '../utils/validation.js';
+
+export const name = 'css';
+export const description = 'Validates src CSS for forbidden class prefixes';
+
+const FORBIDDEN_CLASS_PREFIX = /\.(?<prefix>mds)-[a-z0-9-]+/gi;
+
+/**
+ * Recursively collect all CSS files under a directory.
+ *
+ * @param {string} dirPath
+ * @returns {Array<string>}
+ */
+function getCssFilesRecursive(dirPath) {
+  const cssFiles = [];
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      cssFiles.push(...getCssFilesRecursive(entryPath));
+      continue;
+    }
+
+    if (entry.isFile() && ['.css', '.scss'].includes(path.extname(entry.name).toLowerCase())) {
+      cssFiles.push(entryPath);
+    }
+  }
+
+  return cssFiles;
+}
+
+/**
+ * @property {object} options
+ * @property {FertConfig} options.fertConfig
+ * @returns {Promise<Array<ValidationResult>>}
+ */
+export async function validate({ fertConfig }) {
+  const resultsCollection = validation.createResultCollection();
+  const srcPath = path.resolve(fertConfig.workingDir, 'src');
+
+  if (!fs.existsSync(srcPath)) {
+    return resultsCollection.results;
+  }
+
+  const cssFiles = getCssFilesRecursive(srcPath);
+
+  for (const cssFilePath of cssFiles) {
+    let cssContent;
+    try {
+      cssContent = fs.readFileSync(cssFilePath, 'utf-8');
+    } catch (error) {
+      resultsCollection.addResult('Error reading CSS file').err().filePath(cssFilePath).detail(error.message);
+      continue;
+    }
+
+    const matches = [...cssContent.matchAll(FORBIDDEN_CLASS_PREFIX)];
+    if (!matches.length) continue;
+
+    const offendingPrefixes = [...new Set(matches.map((match) => `${match.groups?.prefix}-`))];
+    for (const prefix of offendingPrefixes) {
+      resultsCollection
+        .addResult(`Found forbidden class prefix ${prefix} in ${cssFilePath}`)
+        .filePath(cssFilePath)
+        .detail('Class prefixes starting with mds- should not be used in dist CSS files.');
+    }
+  }
+
+  return resultsCollection.results;
+}

package/bin/validators/nav-links.validator.js

@@ -0,0 +1,74 @@
+import { glob } from 'node:fs/promises';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as validation from '../utils/validation.js';
+
+export const name = 'nav-links';
+export const description = 'Validates navigation link href conventions per service type';
+
+/** Expected href conventions per service */
+const SERVICE_CONVENTIONS = {
+  'jobseekers-frontend': { pattern: /^\/staticpages(\/|$)/, expected: '/staticpages' },
+  'recruiterservices-frontend': { pattern: /^\/static-page(\/|$)/, expected: '/static-page' },
+};
+
+/**
+ * Extract all static-page href values from template content using regex.
+ * Matches hrefs starting with /static-page/ or /staticpages/.
+ * Supports both JavaScript object literal syntax (href: "...") and HTML attribute syntax (href="...").
+ *
+ * @param {string} content
+ * @returns {Array<string>}
+ */
+export function extractStaticPageHrefs(content) {
+  const hrefRegex = /['"]?href['"]?\s*[:=]\s*['"](\/(static-page|staticpages)\/[^'"]*)['"]/gi;
+  const hrefs = [];
+  let match;
+  while ((match = hrefRegex.exec(content)) !== null) {
+    hrefs.push(match[1]);
+  }
+  return hrefs;
+}
+
+/**
+ * @param {object} options
+ * @param {FertConfig} options.fertConfig
+ * @returns {Promise<Array<ValidationResult>>}
+ */
+export async function validate({ fertConfig }) {
+  const resultsCollection = validation.createResultCollection();
+  const templatesDir = path.resolve(fertConfig.workingDir, 'templates');
+  const convention = SERVICE_CONVENTIONS[fertConfig.serviceName];
+
+  const templateFiles = await Array.fromAsync(glob('**/*.njk', { cwd: templatesDir }));
+
+  if (templateFiles.length === 0) {
+    resultsCollection
+      .addResult('No templates found, skipping nav link validation')
+      .detail(`Expected .njk templates in ${templatesDir}`);
+    return resultsCollection.results;
+  }
+
+  for (const file of templateFiles) {
+    const templatePath = path.join(templatesDir, file);
+    const content = fs.readFileSync(templatePath, 'utf-8');
+    const staticPageHrefs = extractStaticPageHrefs(content);
+
+    if (staticPageHrefs.length === 0 || !convention) continue;
+
+    const failing = staticPageHrefs.filter((href) => !convention.pattern.test(href));
+
+    if (failing.length === 0) continue;
+
+    resultsCollection
+      .addResult(
+        `${failing.length} of ${staticPageHrefs.length} static page link(s) do not follow the convention for ${fertConfig.serviceName}`,
+      )
+      .filePath(templatePath)
+      .detail(
+        `${fertConfig.serviceName} should use '${convention.expected}' prefix. Failing links:\n${failing.map((h) => `  - ${h}`).join('\n')}`,
+      );
+  }
+
+  return resultsCollection.results;
+}

package/bin/validators/required-assets.validator.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import * as validation from '../utils/validation.js';
+import { exists } from '../utils/index.js';
+
+export const name = 'required-assets';
+export const description = 'Validates that required asset files exist in the service public directory';
+
+/**
+ * Main validation function.
+ * Checks for required assets like favicon.ico
+ * @property {object} options
+ * @property {FertConfig} options.fertConfig - Resolved config
+ * @returns {Promise<Array<ValidationResult>>} Array of validation results
+ */
+export async function validate({ fertConfig }) {
+  const resultsCollection = validation.createResultCollection();
+
+  const publicDir = path.resolve(fertConfig.workingDir, 'public');
+
+  // Check for favicon.ico (ERROR if missing)
+  const faviconPath = path.join(publicDir, 'images', 'favicon.ico');
+  if (!(await exists(faviconPath))) {
+    resultsCollection
+      .addResult('Missing required favicon.ico')
+      .err()
+      .filePath(faviconPath)
+      .detail('Every service must include a favicon.ico file at public/images/favicon.ico');
+  }
+
+  // TODO: Add font file validation (WARNING) if referenced in brand.json or CSS
+  // TODO: Add icon file validation (WARNING) if referenced in templates or CSS
+
+  return resultsCollection.results;
+}

package/bin/validators/service-config.validator.js

@@ -0,0 +1,121 @@
+import path from 'node:path';
+import * as validation from '../utils/validation.js';
+import { FERT_SERVICE_CONFIG_FILENAME } from '../../constants.js';
+import { exists, loadConfigFromFile } from '../utils/index.js';
+
+export const name = 'service-config';
+export const description = 'Validates fert.service.config.js structure and required fields';
+
+/**
+ * Main validation function.
+ * Validates the raw service config file (not the merged/resolved fertConfig).
+ * @property {object} options
+ * @property {FertConfig} options.fertConfig - Resolved config (used to locate the raw config file)
+ * @returns {Promise<Array<ValidationResult>>} Array of validation results
+ */
+export async function validate({ fertConfig }) {
+  const resultsCollection = validation.createResultCollection();
+
+  const configPath = path.resolve(fertConfig.workingDir, FERT_SERVICE_CONFIG_FILENAME);
+
+  // Load raw service config from file
+  if (!(await exists(configPath))) {
+    resultsCollection
+      .addResult(`Service config file not found: ${FERT_SERVICE_CONFIG_FILENAME}`)
+      .err()
+      .filePath(configPath)
+      .detail('Each service must have a fert.service.config.js file');
+    return resultsCollection.results;
+  }
+
+  let rawConfig;
+  try {
+    rawConfig = await loadConfigFromFile({
+      dir: fertConfig.workingDir,
+      filename: FERT_SERVICE_CONFIG_FILENAME,
+      silent: true,
+    });
+
+    if (!rawConfig) {
+      resultsCollection
+        .addResult(`Failed to load service config file`)
+        .err()
+        .filePath(configPath)
+        .detail('The config file could not be imported. Check for syntax errors.');
+      return resultsCollection.results;
+    }
+  } catch (err) {
+    resultsCollection
+      .addResult(`Failed to parse service config: ${err.message}`)
+      .err()
+      .filePath(configPath)
+      .detail('Ensure the file exports a valid configuration object');
+    return resultsCollection.results;
+  }
+
+  // Validate serviceName (required, ERROR)
+  if (!rawConfig.serviceName) {
+    resultsCollection
+      .addResult('Missing required field: serviceName')
+      .err()
+      .filePath(configPath)
+      .detail('serviceName must be specified as a string (e.g., "jobseekers-frontend")');
+  } else if (typeof rawConfig.serviceName !== 'string') {
+    resultsCollection
+      .addResult('Invalid serviceName type')
+      .err()
+      .filePath(configPath)
+      .detail(`serviceName must be a string, got ${typeof rawConfig.serviceName}`);
+  } else if (rawConfig.serviceName.trim() === '') {
+    resultsCollection
+      .addResult('serviceName cannot be empty')
+      .err()
+      .filePath(configPath)
+      .detail('serviceName must be a non-empty string (e.g., "jobseekers-frontend")');
+  }
+
+  // Validate entry (required, ERROR)
+  if (!rawConfig.entry) {
+    resultsCollection
+      .addResult('Missing required field: entry')
+      .err()
+      .filePath(configPath)
+      .detail('entry must be specified as a string path (e.g., "./src/index.js")');
+  } else if (typeof rawConfig.entry !== 'string') {
+    resultsCollection
+      .addResult('Invalid entry type')
+      .err()
+      .filePath(configPath)
+      .detail(`entry must be a string, got ${typeof rawConfig.entry}`);
+  }
+
+  // Validate externalAssets.links (optional, WARNING)
+  if (rawConfig.externalAssets?.links !== undefined) {
+    const { links } = rawConfig.externalAssets;
+    const isValidType =
+      typeof links === 'string' || (Array.isArray(links) && links.every((link) => typeof link === 'string'));
+
+    if (!isValidType) {
+      resultsCollection
+        .addResult('Invalid externalAssets.links type')
+        .filePath(configPath)
+        .detail('externalAssets.links must be a string or an array of strings');
+    }
+  }
+
+  // Validate externalAssets.scripts (optional, WARNING)
+  if (rawConfig.externalAssets?.scripts !== undefined) {
+    const { scripts } = rawConfig.externalAssets;
+    const isValidType =
+      typeof scripts === 'string' || (Array.isArray(scripts) && scripts.every((script) => typeof script === 'string'));
+
+    if (!isValidType) {
+      resultsCollection
+        .addResult('Invalid externalAssets.scripts type')
+        .filePath(configPath)
+        .detail('externalAssets.scripts must be a string or an array of strings');
+    }
+  }
+
+  return resultsCollection.results;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madgex/fert",
-  "version": "7.3.0",
+  "version": "7.4.0",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"