@madgex/fert 7.2.0 → 7.3.0

package/README.md

@@ -341,3 +341,53 @@ Here are the default npm scripts in a Fert-scaffolded project.
   }
 }
 ```
+
+## Local Development
+
+Use this when you want to test or debug this local FERT codebase against a real branding repo.
+
+Link the local package:
+
+```bash
+cd ~/Repos/madgex-frontend-rollout-tool
+npm link
+
+cd ~/Repos/madgex-ff6102ff-0f4b-43d1-a2c7-83b835b8dee5
+npm link @madgex/fert
+```
+
+That gives you both of these:
+
+- a global `fert` command pointing at this local repo
+- a linked `@madgex/fert` inside the branding repo's `node_modules`
+
+From the branding repo, the closest match to normal usage is to run the repo scripts or `npx fert`:
+
+```bash
+npm run dev
+npx fert validate
+npx fert build --target=production
+npx fert publish --target=dev --dry-run
+```
+
+You can also run `fert ...` directly in a shell after the first `npm link`, because that creates the global symlink.
+
+To step-debug local FERT code in VS Code, open this repo, set breakpoints, open a JavaScript Debug Terminal, `cd` to the branding repo, then run any `fert` command there. Breakpoints in this repo will be hit automatically.
+
+If you do not want to link, run the CLI directly from the branding repo:
+
+```bash
+node ~/Repos/madgex-frontend-rollout-tool/bin/cli.js dev
+node ~/Repos/madgex-frontend-rollout-tool/bin/cli.js validate
+```
+
+To revert back to the published package:
+
+```bash
+cd ~/Repos/madgex-ff6102ff-0f4b-43d1-a2c7-83b835b8dee5
+npm unlink @madgex/fert
+npm install
+
+cd ~/Repos/madgex-frontend-rollout-tool
+npm unlink
+```

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,10 @@ export async function build(options = {}) {
     throw Error(`Missing or invalid --target option. Choose from [${validTargets}]`);
   }
 
-  await validation.runServiceValidators(['brand-json', 'translations'], { fertConfig, throwable: true });
+  await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], {
+    fertConfig,
+    throwable: true,
+  });
 
   if (!options.only) {
     await rimraf(path.resolve(fertConfig.workingDir, 'dist'));

package/bin/commands/dev-server.js

@@ -33,10 +33,10 @@ 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'], { fertConfig });
+    await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], { fertConfig });
   });
   // initial validation run
-  await validation.runServiceValidators(['brand-json', 'translations'], { fertConfig });
+  await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], { fertConfig });
 
   // building tokens
   await buildTokens(fertConfig);

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/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'], {
+    await validation.runServiceValidators(['brand-json', 'translations', 'redirects-csv'], {
       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

@@ -2,9 +2,10 @@ import chalk from 'chalk';
 import { log } from './logging.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';
 
 /** @type {Array<Validator>} */
-const validators = [validatorBrandJson, validatorTranslations];
+const validators = [validatorBrandJson, validatorTranslations, validatorRedirectsCsv];
 
 /**
  *

package/bin/validators/redirects-csv.validator.js

@@ -0,0 +1,147 @@
+import { REDIRECTS_CSV_FILENAME } from '../../constants.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import * as validation from '../utils/validation.js';
+
+export const name = 'redirects-csv';
+export const description = 'Validates redirects.csv for correct formatting and valid status codes';
+
+const VALID_STATUS_CODES = ['301', '302', '307', '308'];
+
+/**
+ * Extract `{name}` tokens from a Hapi Call path or string-template string.
+ * Hapi wildcards like `{name*}` or `{name*2}` are normalised to `name`.
+ */
+function extractParamNames(str) {
+  const names = new Set();
+  const re = /\{([^}]+)\}/g;
+  let m;
+  while ((m = re.exec(str)) !== null) {
+    const raw = m[1];
+    // strip Hapi wildcard suffix e.g. `name*`, `name*2`
+    const name = raw.replace(/\*\d*$/, '');
+    names.add(name);
+  }
+  return names;
+}
+
+function isAbsoluteUrl(str) {
+  return /^https?:\/\//i.test(str);
+}
+
+/** Strip trailing slash, matching the redirect consumer's behaviour. */
+function stripTrailingSlash(str) {
+  return str.length > 1 && str.endsWith('/') ? str.slice(0, -1) : str;
+}
+
+export async function validate({ fertConfig }) {
+  const resultsCollection = validation.createResultCollection();
+
+  const redirectsCsvPath = path.join(fertConfig.workingDir, 'public', REDIRECTS_CSV_FILENAME);
+  if (!fs.existsSync(redirectsCsvPath)) {
+    return resultsCollection.results;
+  }
+
+  let csvData;
+  try {
+    csvData = fs.readFileSync(redirectsCsvPath, 'utf-8');
+  } catch (error) {
+    resultsCollection
+      .addResult(`Error reading ${REDIRECTS_CSV_FILENAME}`)
+      .filePath(redirectsCsvPath)
+      .err()
+      .detail(error.message);
+    return resultsCollection.results;
+  }
+
+  const lines = csvData.split('\n');
+  const seenSources = new Map(); // source -> first line number where seen
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === '') continue;
+
+    const parts = line.split(',').map((part) => part.trim());
+    const source = parts[0];
+    const destination = parts[1];
+    const status = parts[2];
+    const lineRef = `Line ${i + 1}: "${line.trim()}"`;
+
+    const addError = (message, detail) =>
+      resultsCollection.addResult(`${message}: ${lineRef}`).filePath(redirectsCsvPath).err().detail(detail);
+
+    // Column count — need at least source + destination
+    if (parts.length < 2) {
+      addError('Missing destination', 'Each row must have at least "source,destination"');
+      continue;
+    }
+
+    // Source
+    if (!source) {
+      addError('Missing source', 'Source (column 1) is required');
+    } else {
+      if (!source.startsWith('/')) {
+        addError('Source must start with /', `Source "${source}" must start with a /`);
+      }
+      if (source.includes('?') || source.includes('#')) {
+        addError(
+          'Source must not contain ? or #',
+          `Source "${source}" must not include query strings or fragments — the redirect handler preserves the request query string automatically`,
+        );
+      }
+    }
+
+    // Destination
+    if (!destination) {
+      addError('Missing destination', 'Destination (column 2) is required');
+    } else if (!destination.startsWith('/') && !isAbsoluteUrl(destination)) {
+      addError(
+        'Destination must be a relative path or absolute URL',
+        `Destination "${destination}" must start with / or be an absolute http(s):// URL`,
+      );
+    }
+
+    // Self-redirect + path-parameter consistency
+    if (source && destination) {
+      if (stripTrailingSlash(source) === stripTrailingSlash(destination)) {
+        addError(
+          'Self-redirect',
+          `Source and destination are the same ("${source}") — this would create an infinite redirect loop`,
+        );
+      }
+
+      const sourceParams = extractParamNames(source);
+      const destParams = extractParamNames(destination);
+      for (const p of destParams) {
+        if (!sourceParams.has(p)) {
+          addError(
+            'Destination references unknown path parameter',
+            `Destination "${destination}" references {${p}} which is not captured in source "${source}"`,
+          );
+        }
+      }
+    }
+
+    // Status code
+    if (status && !VALID_STATUS_CODES.includes(status)) {
+      addError(
+        'Invalid status code',
+        `Status "${status}" is not supported. Use 301 (permanent) or 302 (temporary); 307/308 preserve the HTTP method`,
+      );
+    }
+
+    // Duplicate source
+    if (source) {
+      if (seenSources.has(source)) {
+        addError(
+          'Duplicate source',
+          `Source "${source}" is already defined on line ${seenSources.get(source)} — only the first occurrence is applied`,
+        );
+      } else {
+        seenSources.set(source, i + 1);
+      }
+    }
+  }
+
+  return resultsCollection.results;
+}

package/constants.js

@@ -19,6 +19,7 @@ export const AWS_REGION = 'eu-west-1';
 export const PROPERTY_ID_API = 'https://property-identification-api.cs.madgexhosting.net/properties/';
 export const ASSETS_API_URL = 'https://asset-store.job.madgexhosting.net';
 export const BRAND_JSON_FILENAME = 'brand.json';
+export const REDIRECTS_CSV_FILENAME = 'redirects.csv';
 export const FERT_CONFIG_FILENAME = 'fert.config.js';
 export const FERT_SERVICE_CONFIG_FILENAME = 'fert.service.config.js';
 export const ASSET_STORE_API = 'https://asset-store-api.job.madgexhosting.net/';
@@ -46,8 +47,6 @@ export const ASSET_STORE_INVALIDATION_PATH = `/{fertConfig.client.rootClientProp
 
 export const ASSET_STORE_USER_GUID = 'a386d4b6-f2df-4b80-ad1f-0349e23f530b';
 
-export const CONFIG_API =
-  'https://configuration-api.job.madgexhosting.net/configs/override/{cpid}/production/{configGroup}/{config}';
 export const CONFIG_DIR = 'config';
 
 /** we assume the remove version of a service hosts an api translations endpoint */

package/docs/FAQ.md

@@ -0,0 +1 @@
+-