@madgex/fert 7.2.1 → 7.4.0

package/bin/cli.js

@@ -12,6 +12,7 @@ import { configsCommand } from './commands/configs.js';
 import { initCommand } from './commands/init.js';
 import { validateCommand } from './commands/validate.js';
 import { rootTasksBootstrap } from './commands/_root-tasks-bootstrap.js';
+import { initTemplateCommand } from './commands/init-template.js';
 
 const cli = cac('fert');
 
@@ -66,6 +67,9 @@ const run = () => {
     .command('init [root]', 'Create a new branding project')
     .option('--cpid <cpid>', 'Specify the clientPropertyId to use in the new project')
     .action((...args) => initCommand(...args));
+  cli
+    .command('init-template', 'Create a custom template for a specific service & header or footer')
+    .action((...args) => initTemplateCommand(...args));
 
   cli.command('validate', 'Validate branding project for common issues').action((...args) => validateCommand(...args));
 

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/init-template-tasks/copy-theme-files.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { log } from '../../utils/logging.js';
+import { getOutDir } from './get-out-dir.js';
+import { getNunjucksDependencies } from './get-nunjucks-dependencies.js';
+
+/**
+ * Collect all dependency include/import files (and all icon .svg files) for a given theme entry file.
+ * Copy all these files to new output directory (e.g. service's templates folder)
+ * Main macro inside entryFilePath is renamed to `CUSTOM`
+ * @param {import('../init-template.js').Result} result
+ * @param {string} themeDir absolute dir path of `theme` folder in header footer podlet package
+ */
+export async function copyThemeFiles(result, themeDir) {
+  const outDir = getOutDir(result);
+  const { entryFilePath } = result.theme;
+  // icons are dynamic includes, so we grab all `.svg` icon paths to copy along with everything else
+  const iconFiles = await Array.fromAsync(fs.promises.glob(path.resolve(themeDir, '_common/icons/*.svg')));
+
+  // Discover all dependencies starting from the input file
+  const collectedFiles = new Set([...getNunjucksDependencies(entryFilePath), ...iconFiles]);
+
+  // Create output directory and copy all files
+  fs.mkdirSync(outDir, { recursive: true });
+
+  for (const absPath of collectedFiles) {
+    const relPath = path.relative(themeDir, absPath);
+    const destPath = path.join(outDir, relPath);
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+    const source = fs.readFileSync(absPath, 'utf8');
+    let rewritten = prependTemplatePaths(source);
+    // this is the entry file
+    if (absPath === entryFilePath) {
+      rewritten = rewritten.replaceAll(result.theme.themeName, 'CUSTOM');
+    }
+    fs.writeFileSync(destPath, rewritten, 'utf8');
+  }
+
+  log.success(`\nStandalone editable theme initialised at: ${outDir}`);
+}
+
+/**
+ * Rewrite import/include paths in a file to prepend `templatePath` variable.
+ * `templatePath` required to make header-footer-podlet imports work with its HTTP nunjucks loader
+ * @param {string} source - The file contents
+ * @returns {string} The rewritten source
+ */
+export function prependTemplatePaths(source) {
+  return source
+    .replace(
+      // Rewrite from-imports: {% from 'path' import ... %} -> {% from templatePath + 'path' import ... %}
+      /(\{%-?\s*from\s+)/g,
+      (match, prefix) => `${prefix}templatePath + `,
+    )
+    .replace(
+      // Rewrite includes: {% include 'path' %} -> {% include templatePath + 'path' %}
+      /(\{%-?\s*include\s+)/g,
+      (match, prefix) => `${prefix}templatePath + `,
+    );
+}

package/bin/commands/init-template-tasks/generate-entry-nunjucks-file.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as vite from 'vite';
+
+/**
+ * Create new entry file (e.g. `header.njk` or `footer.njk`), pointing at the new copied theme macro called `CUSTOM`.
+ * Also generate the correct arguments to pass to the macro using the Storybook story for that theme.
+ *
+ * @param {import('../init-template.js').Result} result
+ * @param {string} hfpDir absolute dir path for header footer podlet package
+ * @param {string} themeDir absolute dir path of `theme` folder in header footer podlet package
+ * */
+export async function generateEntryNunjucksFile(result, hfpDir, themeDir) {
+  const { entryFilePath, type } = result.theme;
+
+  // the story file for the theme, we are trusting the filename contains the theme name
+  const storyFile = path.resolve(hfpDir, `.storybook/stories/components/${result.theme.themeName}.stories.jsx`);
+
+  /** Bundle the story file as CJS, stubbing out ServerRender to avoid React requirement */
+  const response = await vite.build({
+    root: path.dirname(storyFile),
+    plugins: [
+      {
+        name: 'stub-server-render',
+        enforce: 'pre',
+        resolveId(source) {
+          // replace import with replaceable string
+          if (source.endsWith('ServerRender.jsx')) return '\0server-render-stub';
+          return undefined;
+        },
+        load(id) {
+          // replace string with empty const, we don't need/want `ServerRender`, we just want `default.args` object
+          if (id === '\0server-render-stub') return 'export const ServerRender = null;';
+          return undefined;
+        },
+      },
+    ],
+    build: {
+      lib: { entry: storyFile, formats: ['cjs'] },
+      write: false,
+      rollupOptions: { output: { sourcemap: false, manualChunks: undefined } }, // all in 1 "file" output
+    },
+    logLevel: 'silent',
+  });
+
+  /** Evaluate the CJS bundle to extract the default export's args */
+  const code = response[0].output[0].code;
+  const moduleExports = {};
+  const moduleObj = { exports: moduleExports };
+  new Function('exports', 'module', code)(moduleExports, moduleObj);
+
+  const args = moduleObj.exports.default.args;
+
+  args.serviceName = result.service.serviceConfig.serviceName;
+
+  const rootDir = path.resolve(result.service.dir, 'templates');
+  const relEntryFilePath = path.relative(themeDir, entryFilePath);
+  const argsJson = JSON.stringify(args, null, 4);
+  fs.writeFileSync(
+    path.join(rootDir, `${type}.njk`),
+    `{% from templatePath + './custom-${type}/${relEntryFilePath}' import CUSTOM with context %}\n{{ CUSTOM(${argsJson}) }}\n`,
+    { encoding: 'utf-8' },
+  );
+}

package/bin/commands/init-template-tasks/get-macro-name-from-nunjucks.js

@@ -0,0 +1,13 @@
+import * as parser from 'nunjucks/src/parser.js';
+import * as nodes from 'nunjucks/src/nodes.js';
+
+/**
+ * Extract the first macro name from a template source.
+ * @param {string} source - The file contents
+ */
+export function getMacroNameFromNunjucks(source) {
+  const ast = parser.parse(source);
+  const macros = ast.findAll(nodes.Macro);
+  if (macros.length === 0) return undefined;
+  return macros[0].name.value;
+}

package/bin/commands/init-template-tasks/get-nunjucks-dependencies.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as parser from 'nunjucks/src/parser.js';
+import * as nodes from 'nunjucks/src/nodes.js';
+
+/**
+ * Recursively discover all included/imported files using the nunjucks AST, given an entry nunjucks file
+ * @param {string} filePath - Absolute path to the entry file
+ * @param {Set<string>} _discovered - Set of all discovered absolute file paths
+ * @returns {Set<string>} Set of all discovered absolute file paths (including the entry)
+ */
+export function getNunjucksDependencies(filePath, _discovered = new Set()) {
+  let discovered = new Set(_discovered);
+  if (discovered.has(filePath)) return discovered;
+  discovered.add(filePath);
+
+  if (!fs.existsSync(filePath)) {
+    console.error(`WARNING: File not found: ${filePath}`);
+    return discovered;
+  }
+
+  const source = fs.readFileSync(filePath, 'utf8');
+  const dir = path.dirname(filePath);
+
+  for (const relDepPath of getDependencyPaths(source)) {
+    const absDepPath = path.resolve(dir, relDepPath);
+    discovered = getNunjucksDependencies(absDepPath, discovered);
+  }
+  return discovered;
+}
+
+/**
+ * Extract all template paths (from imports and includes) from a source string using the AST.
+ * Dynamic imports and includes are not collected.
+ *
+ * @param {string} source - Nunjucks template source
+ * @returns {string[]} Array of *relative* paths referenced in the template
+ */
+export function getDependencyPaths(source) {
+  const ast = parser.parse(source);
+  const paths = [];
+
+  for (const node of ast.findAll(nodes.FromImport)) {
+    // `node.template.value` will not exist for dynamic import
+    if (node.template && node.template.value) {
+      paths.push(node.template.value);
+    }
+  }
+
+  for (const node of ast.findAll(nodes.Include)) {
+    // `node.template.value` will not exist for dynamic include
+    if (node.template && node.template.value) {
+      paths.push(node.template.value);
+    }
+  }
+
+  return paths;
+}

package/bin/commands/init-template-tasks/get-out-dir.js

@@ -0,0 +1,6 @@
+import path from 'node:path';
+
+/** @param {import("../init-template.js").Result} result */
+export function getOutDir(result) {
+  return path.resolve(result.service.dir, 'templates', `custom-${result.theme.type}`);
+}

package/bin/commands/init-template.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { findFertConfigDir, loadServiceConfigFiles } from '../utils/index.js';
+import { log } from '../utils/logging.js';
+import { generateEntryNunjucksFile } from './init-template-tasks/generate-entry-nunjucks-file.js';
+import { copyThemeFiles } from './init-template-tasks/copy-theme-files.js';
+import { getMacroNameFromNunjucks } from './init-template-tasks/get-macro-name-from-nunjucks.js';
+
+/** header-footer-podlet-server package root dir */
+const hfpDir = path.dirname(fileURLToPath(import.meta.resolve('@private/header-footer-podlet-server/package.json')));
+/** main themes dir inside header-footer-podlet-server */
+const themeDir = path.resolve(hfpDir, 'lib/templates/themes');
+
+/**
+ * Object constructed based on user selection - has all info required to copy a theme's files to the correct service template dir
+ * @typedef Result
+ * @type {object}
+ * @property {{dir:string, serviceConfig: FertServiceConfigFile}}  service
+ * @property {{type:"header"|"footer", themeName:string, entryFilePath:string}} theme
+ * */
+
+/**
+ * This command copies theme files from header-footer-podlet, into a service's template folder, to be used standalone for creating custom headers and footers.
+ *
+ * 1. collect user prompt choices
+ * 2. copy theme files based on choices - modified files to use `templatePath` and rename the theme macro name to `CUSTOM`
+ * 3. create new entry file (header.njk or footer.njk) pointing to the copied theme files
+ */
+export async function initTemplateCommand(/* options = {} */) {
+  /** @type {Result} */
+  let result;
+  const rootDir = await findFertConfigDir();
+
+  const serviceConfigs = await loadServiceConfigFiles();
+  if (!serviceConfigs.length) {
+    log.warn('No services found to populate with template');
+    return;
+  }
+
+  /** entry file paths for each theme, all entry files are named `header.njk` or `footer.njk` */
+  let themes = await Array.fromAsync(fs.promises.glob(path.resolve(themeDir, '**/{header,footer}.njk')));
+  // cheeky hardcode exclude `simplified` themes, as they are not really to be used again
+  themes = themes.filter((theme) => !theme.includes('simplified'));
+
+  /** @type {prompts.PromptObject[]} Ask user which service to copy files to, and which theme to copy */
+  const promptArr = [
+    {
+      type: 'select',
+      name: 'service',
+      message: 'Which Service?',
+      choices: serviceConfigs.map((item) => ({
+        title: item.serviceConfig.serviceName,
+        description: `Found at ${path.relative(rootDir, item?.dir)}`,
+        value: item,
+      })),
+      initial: 0,
+    },
+    {
+      type: 'select',
+      name: 'theme',
+      message: 'Which Theme?',
+      choices: themes.map((themeEntryFilePath) => {
+        // cheekily get `header` or `footer` "type" from the filename, we only collected `header.njk` and `footer.njk` in `themes` glob above.
+        const type = path.basename(themeEntryFilePath, '.njk');
+        const entryFileNjkSrc = fs.readFileSync(themeEntryFilePath, 'utf-8');
+        const themeName = getMacroNameFromNunjucks(entryFileNjkSrc);
+        return {
+          title: themeName,
+          description: `Type: ${type}`,
+          value: { type, themeName, entryFilePath: themeEntryFilePath },
+        };
+      }),
+      initial: 0,
+    },
+  ];
+
+  try {
+    result = await prompts(promptArr, {
+      onCancel: () => {
+        throw new Error(chalk.red('✖') + ' Operation cancelled');
+      },
+    });
+  } catch (cancelled) {
+    console.log(cancelled.message);
+    return;
+  }
+
+  await copyThemeFiles(result, themeDir);
+
+  await generateEntryNunjucksFile(result, hfpDir, themeDir);
+}

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/cpid-lookup.js

@@ -16,8 +16,9 @@ export async function doCpidLookup(clientPropertyId) {
       throw new Error(`${results.status} - ${errorMessage}`);
     }
     const { data } = await results.json();
-    const { brandName, parentId: parentCpid } = data;
+    const { name, brandName, parentId: parentCpid } = data;
     return {
+      name,
       brandName,
       parentCpid: parentCpid ?? false,
       rootClientPropertyId: parentCpid ?? clientPropertyId,

package/bin/utils/get-assets-path.js

@@ -3,12 +3,12 @@ import { ASSET_RELAY_API } from '../../constants.js';
 /**
  * fetch the Absolute URL `publicUrl` from asset-relay API, for current client & service
  *
- * @param {object} fertConfig
+ * @param {FertConfig} fertConfig
  * @param {object} environment
- * @returns {URL} Absoloute Public URL for assets
+ * @returns {URL} Absolute Public URL for assets
  */
 export async function getAssetsPath(fertConfig, environment) {
-  const { clientPropertyId, serviceName, client, config } = fertConfig;
+  const { clientPropertyId, serviceName, client } = fertConfig;
 
   // Try to get existing mapping
   const getUrl = new URL(ASSET_RELAY_API);
@@ -26,7 +26,7 @@ export async function getAssetsPath(fertConfig, environment) {
         clientPropertyId,
         rootClientPropertyId: client.rootClientPropertyId,
         serviceName,
-        siteName: config.SiteName,
+        siteName: client.name || client.brandName,
       }),
     });
 

package/bin/utils/index.js

@@ -12,35 +12,12 @@ import { cpidLookup } from './cpid-lookup.js';
 import { cpIdMatchesGitRemote } from './cpid-matches-git-remote.js';
 import { resolveExternalAssets } from './resolve-external-assets.js';
 import { log } from './logging.js';
-import { CONFIG_API, VERSION, FERT_CONFIG_FILENAME, FERT_SERVICE_CONFIG_FILENAME } from '../../constants.js';
+import { VERSION, FERT_CONFIG_FILENAME, FERT_SERVICE_CONFIG_FILENAME } from '../../constants.js';
 
 export function printBanner() {
   console.log(`\n${chalk.green.bold('Fert')} v${VERSION}`);
 }
 
-/**
- * get a config values from `clientconfig` from config-api
- *
- * @param {string} cpid
- * @param {Array<string>} configNames array of config keys to fetch from clientconfig
- * @returns
- */
-export async function getClientConfig(cpid, configNames = []) {
-  Hoek.assert(Array.isArray(configNames), 'configNames must be an array');
-
-  const result = {};
-
-  for (let config of configNames) {
-    const url = CONFIG_API.replace('{configGroup}', 'clientconfig').replace('{cpid}', cpid).replace('{config}', config);
-    const { data } = await fetch(url).then((response) => response.json());
-    const { value } = data?.[0] || {};
-
-    result[config] = value;
-  }
-
-  return result;
-}
-
 export async function resolveConfig(options = {}) {
   Hoek.assert(options.serviceName, 'serviceName is required');
 
@@ -96,8 +73,6 @@ export async function resolveConfig(options = {}) {
 
   fertConfig.externalAssets = resolveExternalAssets(fertConfig.externalAssets);
 
-  fertConfig.config = await getClientConfig(fertConfig.clientPropertyId, ['JobseekerSiteWebSitePath', 'SiteName']);
-
   return {
     ...fertConfig,
     rootDir,

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