@madgex/fert 4.2.6 → 5.0.1

package/README.md

@@ -42,9 +42,25 @@ To empower & serve its users, we should design this CLI with the users in mind.
 
 # Configuration
 
-There are **three required files** in the root of the branding repo:
+There are **two required files** in the root of the branding repo, and **two required files** in the service folder:
 
-`brand.json` [required] – a JSON file that supplies the base branding tokens. These values will be merged with the Design System tokens & a full set of branding tokens will be created. [see here for format](https://github.com/wiley/madgex-design-system/tree/master/packages/%40madgex.design-system/src/tokens)
+`/fert.config.js` [required] – a configuration file in the root of the branding repo specifying the following config to both the Fert dev server and the production asset build:
+
+| Option                      |                                                                     |
+| --------------------------- | ------------------------------------------------------------------- |
+| `clientPropertyId` <String> | The `clientPropertyId` associated with the branding repo (required) |
+
+e.g.
+
+```js
+module.exports = {
+  clientPropertyId: 'ff6102ff-0f4b-43d1-a2c7-83b835b8dee5',
+};
+```
+
+`/jenkinsfile` - A jenkins file in the root of the repo containing the pipeline which will build and send the assets to S3. Every push to the repo will trigger a jenkins build automatically. Changes on **master** will trigger a build and send assets to the **production** bucket. Any other branches will send the assets to the jb.dev bucket.
+
+`/services/<service-folder>/brand.json` [required] – a JSON file in a service folder that supplies the base branding tokens. These values will be merged with the Design System tokens & a full set of branding tokens will be created. [see here for format](https://github.com/wiley/madgex-design-system/tree/master/packages/%40madgex.design-system/src/tokens)
 
 e.g.
 
@@ -61,13 +77,13 @@ e.g.
 }
 ```
 
-`fert.config.js` [required] – a configuration file in the root of the branding repo specifying the following config to both the Fert dev server and the production asset build:
+`/services/<service-folder>/fert.service.config.js` [required] – a service configuration file in the service folder, specifying the following config to both the Fert dev server and the production asset build:
 
-| Option                      |                                                                                                                                            |
-| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| `clientPropertyId` <String> | The `clientPropertyId` associated with the branding repo (required)                                                                        |
-| `entry` <String>            | The JavaScript entry file. Any assets (CSS/SCSS/SVGs) included will be processed and be part of the output. Defaults to `['src/index.js']` |
-| `assumeSite` <String>       | Which site we want to display, jobseeker site or recruiter site. Values are either `js` or `rs`.                                           |
+| Option                    |                                                                                                                                            |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `serviceName` <String>    | Which service to display and deploy, e.g. `jobseekers-frontend`, `recruiterservices-frontend`.                                             |
+| `entry` <String>          | The JavaScript entry file. Any assets (CSS/SCSS/SVGs) included will be processed and be part of the output. Defaults to `['src/index.js']` |
+| `externalAssets` <Object> |                                                                                                                                            |
 
 The `entry` will be used by Vite to create production bundles.
 
@@ -75,14 +91,15 @@ e.g.
 
 ```js
 module.exports = {
-  clientPropertyId: 'ff6102ff-0f4b-43d1-a2c7-83b835b8dee5',
+  serviceName: 'jobseekers-frontend',
   entry: './src/index.js',
-  assumeSite: 'js',
+  externalAssets: {
+    links: [],
+    scripts: [],
+  },
 };
 ```
 
-`jenkinsfile` - A jenkins file containing the pipeline which will build and send the assets to S3. Every push to the repo will trigger a jenkins build automatically. Changes on **master** will trigger a build and send assets to the **production** bucket. Any other branches will send the assets to the jb.dev bucket.
-
 # CLI commands
 
 The CLI will support 3 main commands: dev server (default command), scaffolding a new project and building production assets.
@@ -97,13 +114,16 @@ The CLI will support 3 main commands: dev server (default command), scaffolding
 
 ## Dev server
 
-`fert`
+Start the Fert dev server for 1 or all services:
+`fert` | `fert --service-name=jobseekers-frontend`
 
-Start the Fert dev server in the current directory.
+Start the Fert dev server for 1 service from the service folder:
+`cd services/jobseekers-frontend`
+`fert`
 
 **Usage**
 
-`fert [root]`
+`fert `
 
 **Outline of implementation**
 
@@ -145,13 +165,18 @@ The `init` command is intended for an automation tool which will create a new br
 
 ## Build
 
-`fert build`
-
 Process CSS/JS assets specified in `fert.config.js` and copy static assets, including templates for distribution.
 
+Run for all or a specific service
+`fert build` | `fert build --service-name=jobseekers-frontend`
+
+Run for 1 service from the service folder:
+`cd services/jobseekers-frontend`
+`fert build`
+
 **Usage**
 
-`fert build [root] --only [tokens | assets]`
+`fert build  --only [tokens | assets]`
 
 | Option            |                                                                                                            |
 | ----------------- | ---------------------------------------------------------------------------------------------------------- |
@@ -172,15 +197,21 @@ Templates & CSS may be processed using the [CSS Modules](https://github.com/css-
 
 ## Publish
 
+From root, run for all services or a specific service:
+`fert publish --target=prod` | `fert publish --target=prod --service-name=jobseekers-frontend`
+
+Run for 1 service from the service folder:
+`cd services/jobseekers-frontend`
 `fert publish`
 
 **Usage**
 
-`fert publish [root] --target [target]`
+`fert publish  --target [target]`
 
-| Option     |                                                                              |
-| ---------- | ---------------------------------------------------------------------------- |
-| `--target` | Where to publish the `dist` directory assets.<br/>`dev` \| `prod` (`string`) |
+| Option      |                                                                              |
+| ----------- | ---------------------------------------------------------------------------- |
+| `--target`  | Where to publish the `dist` directory assets.<br/>`dev` \| `prod` (`string`) |
+| `--dry-run` | Dry run, dont actually upload anything                                       |
 
 Send all files and directories created in the `dist` directory to either development or production versions of the Asset Store API. Files uploaded to the Asset Store API are available via a CloudFront-based CDN.
 
@@ -198,7 +229,7 @@ A set of commands to help with publishing, downloading & referencing project con
 
 **Usage**
 
-`fert configs [root] --[query|download|publish] [env]`
+`fert configs  --[query|download|publish] [env]`
 
 | Option               | Description                                                                             |
 | -------------------- | --------------------------------------------------------------------------------------- |

package/bin/cli.js

@@ -6,40 +6,44 @@ const cli = require('cac')('fert');
 const { VERSION } = require('../constants');
 const { printBanner } = require('./utils/index.js');
 
+const {
+  serivceCommandBootstrap,
+} = require('./commands/_service-command-bootstrap.js');
+
 const run = () => {
   printBanner();
 
   cli
     .command(
-      '[root]',
+      '',
       'Start layout server. Can supply a branding directory if running FERT standalone'
     )
     .alias('dev')
     .option('--open', 'Automatically open the dev server in your browser')
     .option('--host [host]', '[string] specify hostname')
     .option('--port <port>', '[number] specify port')
-    .option(
-      '--assume-site [site]',
-      'Use jobseeker or recruiter site, "js" or "rs"'
-    )
-    .action((...args) => require('./commands/dev-server')(...args));
+    .option('--service-name <serviceName>', '[string] run a single service')
+    .action((...args) => serivceCommandBootstrap('dev', ...args));
 
   cli
     .command(
-      'build [root]',
+      'build',
       'Build project. Can supply a branding directory if running FERT standalone'
     )
     .option('--only <task>', `Only run part of the build [ 'assets', 'tokens']`)
     .option('--config [dir]', 'Use custom rollup config file')
-    .action((...args) => require('./commands/build.js')(...args));
+    .option('--service-name <serviceName>', '[string] run a single service')
+    .action((...args) => serivceCommandBootstrap('build', ...args));
 
   cli
-    .command('publish [root]', 'Publish the project')
+    .command('publish', 'Publish the project')
     .option('--target <env>', 'Environment to publish to, "dev" or "prod"')
-    .action((...args) => require('./commands/publish')(...args));
+    .option('--service-name <serviceName>', '[string] run a single service')
+    .option('--dry-run', 'Dry run, dont actually upload anything')
+    .action((...args) => serivceCommandBootstrap('publish', ...args));
 
   cli
-    .command('configs [root]', 'Query/Publish project configs')
+    .command('configs', 'Query/Publish project configs')
     .option(
       '--publish <env>',
       'Publish configs to Configuration API environment "dev" or "production"'

package/bin/commands/_service-command-bootstrap.js

@@ -0,0 +1,71 @@
+const chalk = require('chalk');
+
+const {
+  loadServiceConfigFiles,
+  loadConfigFromFile,
+} = require('../utils/index.js');
+
+const commandDevSever = require('./dev-server.js');
+const commandBuild = require('./build.js');
+const commandPublish = require('./publish.js');
+const { log } = require('../utils/logging.js');
+const { FERT_SERVICE_CONFIG_FILENAME } = require('../../constants.js');
+
+const commandMap = {
+  dev: commandDevSever,
+  build: commandBuild,
+  publish: commandPublish,
+};
+
+/**
+ * determine if we are running a single service, otherwise search for all services
+ * Then run command
+ */
+module.exports.serivceCommandBootstrap = async function serivceCommandBootstrap(
+  command,
+  options
+) {
+  // explicitly run a single service - via CLI option
+  if (options.serviceName) {
+    console.log(`🔦 ${chalk.green('Running single service mode')}`);
+    await commandMap[command](options);
+    return;
+  }
+
+  // explicitly run a single service - if we are inside a service folder
+  try {
+    // try to load service config in process.cwd
+    const serviceConfig = await loadConfigFromFile({
+      dir: process.cwd(),
+      filename: FERT_SERVICE_CONFIG_FILENAME,
+      silent: true,
+    });
+    if (serviceConfig) {
+      console.log(`🔦 ${chalk.green('Running single service mode')}`);
+      await commandMap[command]({
+        ...options,
+        serviceName: serviceConfig.serviceName,
+      });
+      return;
+    }
+  } catch {
+    // no service config file in cwd
+  }
+
+  // not single service - try to find and load all services
+  const serviceConfigs = await loadServiceConfigFiles();
+  console.log(
+    `🔦 ${chalk.green('Running multi service mode')}, searching for services`
+  );
+  for (const { serviceConfig } of serviceConfigs) {
+    try {
+      await commandMap[command]({
+        ...options,
+        serviceName: serviceConfig.serviceName,
+      });
+    } catch (error) {
+      log.error('Failed to run command', command, options, serviceConfig);
+      console.error(error);
+    }
+  }
+};

package/bin/commands/build-tasks/bundle-entry.js

@@ -16,7 +16,7 @@ module.exports = async (fertConfig, options = {}) => {
 
   dynamicOptions = {
     root: path.resolve(fertConfig.workingDir),
-    base: '/_/jobseekers-frontend/assets/',
+    base: `/_/${fertConfig.serviceName}/assets/`,
     build: {
       cssCodeSplit: false, // important: to get a single, style.css file output
       outDir: path.resolve(fertConfig.workingDir, 'dist'),

package/bin/commands/build.js

@@ -7,9 +7,12 @@ const buildCssFromTokens = require('./build-tasks/build-tokens');
 const buildExternalAssets = require('./build-tasks/build-external-assets');
 const { validateLocalConfigs } = require('../utils/configs.js');
 
-module.exports = async (root, options = {}) => {
-  const fertConfig = await resolveConfig(root, options);
-  await validateLocalConfigs(fertConfig, { catch: false });
+module.exports = async (options = {}) => {
+  const fertConfig = await resolveConfig(options);
+  await validateLocalConfigs({
+    workingDir: fertConfig.rootDir,
+    clientPropertyId: fertConfig.clientPropertyId,
+  });
 
   if (!options.only) {
     await rimraf(path.resolve(fertConfig.workingDir, 'dist'));

package/bin/commands/configs.js

@@ -1,4 +1,4 @@
-const { resolveConfig } = require('../utils/index.js');
+const { loadConfigFromFile, findFertConfigDir } = require('../utils/index.js');
 const { getConfigAPI, updateProjectConfigs } = require('../utils/configs.js');
 const chalk = require('chalk');
 const { log } = require('../utils/logging.js');
@@ -8,7 +8,7 @@ const { mkdir, writeFile } = require('node:fs/promises');
 const Path = require('node:path');
 const { CONFIG_DIR } = require('../../constants.js');
 
-const handleDownload = async (fertConfig, api, options) => {
+const handleDownload = async ({ workingDir }, api, options) => {
   const validTargets = ['dev', 'production'];
 
   if (!validTargets.includes(options.download)) {
@@ -77,13 +77,17 @@ const handleDownload = async (fertConfig, api, options) => {
   }
 
   for (const [schemaName, data] of Object.entries(resultObj)) {
-    const filePath = Path.join(CONFIG_DIR, `${schemaName}.json`);
+    const filePath = Path.join(workingDir, CONFIG_DIR, `${schemaName}.json`);
     await writeFile(filePath, JSON.stringify(data, null, 2));
     console.log(` - ${schemaName}.json`);
   }
 };
 
-const handlePublish = async (fertConfig, api, options) => {
+const handlePublish = async (
+  { workingDir, clientPropertyId },
+  api,
+  options
+) => {
   const validTargets = ['dev', 'production'];
 
   if (!validTargets.includes(options.publish)) {
@@ -93,14 +97,23 @@ const handlePublish = async (fertConfig, api, options) => {
   }
 
   try {
-    await updateProjectConfigs(fertConfig, { environment: options.publish });
+    await updateProjectConfigs({
+      workingDir,
+      clientPropertyId,
+      environment: options.publish,
+    });
+    console.log('upload');
   } catch (err) {
     log.debug(err);
     process.exit(1);
   }
 };
 
-const handleQuery = async (fertConfig, api, options) => {
+const handleQuery = async (
+  /* { workingDir, clientPropertyId } */ _,
+  api,
+  options
+) => {
   try {
     if (options.query !== true) {
       console.log(
@@ -141,9 +154,16 @@ const handleQuery = async (fertConfig, api, options) => {
   }
 };
 
-module.exports = async (root, options) => {
-  const fertConfig = await resolveConfig(root, options);
-  const api = await getConfigAPI(fertConfig);
+module.exports = async (options) => {
+  const fertConfigDir = await findFertConfigDir();
+
+  const { clientPropertyId } = await loadConfigFromFile({
+    dir: fertConfigDir,
+  });
+  const api = await getConfigAPI({
+    clientPropertyId,
+    environment: options.environment,
+  });
 
   if (!options.publish && !options.query && !options.download) {
     console.log(
@@ -153,11 +173,23 @@ module.exports = async (root, options) => {
   }
 
   if (options.download) {
-    await handleDownload(fertConfig, api, options);
+    await handleDownload(
+      { clientPropertyId, workingDir: fertConfigDir },
+      api,
+      options
+    );
   } else if (options.publish) {
-    await handlePublish(fertConfig, api, options);
+    await handlePublish(
+      { clientPropertyId, workingDir: fertConfigDir },
+      api,
+      options
+    );
   } else if (options.query) {
-    await handleQuery(fertConfig, api, options);
+    await handleQuery(
+      { clientPropertyId, workingDir: fertConfigDir },
+      api,
+      options
+    );
   }
 };
 

package/bin/commands/configs.test.js

@@ -15,6 +15,7 @@ describe('configs', () => {
 
   beforeEach(async (t) => {
     fertConfig = {
+      workingDir: 'working-dir',
       clientPropertyId: 'ff6102ff-0f4b-43d1-a2c7-83b835b8dee5',
     };
 
@@ -82,7 +83,7 @@ describe('configs', () => {
 
       assert.strictEqual(
         writeFileMock.mock.calls[0].arguments[0],
-        Path.join('config', 'jsfe-config.json')
+        Path.join('working-dir', 'config', 'jsfe-config.json')
       );
     });
 

package/bin/commands/dev-server.js

@@ -2,7 +2,7 @@ const path = require('node:path');
 const chalk = require('chalk');
 const open = require('open');
 const chokidar = require('chokidar');
-const { resolveConfig } = require('../utils/index.js');
+const { resolveConfig, findFertConfigDir } = require('../utils/index.js');
 const { log } = require('../utils/logging.js');
 const { validateLocalConfigs } = require('../utils/configs.js');
 const { devServer } = require('../../server');
@@ -10,26 +10,37 @@ const { buildTokens, buildExternalAssets } = require('./build.js');
 const {
   BRAND_JSON_FILENAME,
   FERT_CONFIG_FILENAME,
+  FERT_SERVICE_CONFIG_FILENAME,
 } = require('../../constants.js');
 
-module.exports = async (root, options = {}) => {
-  let fertConfig = await resolveConfig(root, options);
+module.exports = async (options = {}) => {
+  let fertConfig = await resolveConfig(options);
 
   console.log(
     `Starting branding server for ${chalk.green(
       fertConfig.client.brandName
-    )} [${fertConfig.assumeSite}] ${chalk.dim(
+    )} [${fertConfig.serviceName}] ${chalk.dim(
       `(${fertConfig.clientPropertyId})`
     )}\n`
   );
 
-  await validateLocalConfigs(fertConfig);
+  await validateLocalConfigs({
+    workingDir: fertConfig.rootDir,
+    clientPropertyId: fertConfig.clientPropertyId,
+    throwable: false,
+  });
   await buildTokens(fertConfig);
 
+  const fertConfigDir = await findFertConfigDir();
+
   // watch local configs - revalidate on change
-  const configsPath = path.resolve(fertConfig.workingDir, './config/*.json');
+  const configsPath = path.resolve(fertConfigDir, './config/*.json');
   chokidar.watch(configsPath, { ignoreInitial: true }).on('all', async () => {
-    await validateLocalConfigs(fertConfig);
+    await validateLocalConfigs({
+      workingDir: fertConfig.rootDir,
+      clientPropertyId: fertConfig.clientPropertyId,
+      throwable: false,
+    });
   });
 
   // watch brand.json & fert.config.js - refresh on change
@@ -38,10 +49,14 @@ module.exports = async (root, options = {}) => {
     await buildTokens(fertConfig);
   });
 
-  const configPath = path.resolve(fertConfig.workingDir, FERT_CONFIG_FILENAME);
-  chokidar.watch(configPath).on('change', async () => {
+  const configPath = path.resolve(fertConfigDir, FERT_CONFIG_FILENAME);
+  const serviceConfigPath = path.resolve(
+    fertConfig.workingDir,
+    FERT_SERVICE_CONFIG_FILENAME
+  );
+  chokidar.watch([configPath, serviceConfigPath]).on('change', async () => {
     console.log('Config changed, reloading…');
-    fertConfig = await resolveConfig(root, options);
+    fertConfig = await resolveConfig(options);
     await buildExternalAssets(fertConfig);
 
     // update server's config & tell Vite to refresh the page

package/bin/commands/init.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-unreachable */
 const path = require('node:path');
 const fs = require('node:fs');
 const chalk = require('chalk');
@@ -7,12 +8,13 @@ const ora = require('ora');
 const { cpidLookup } = require('../utils/cpid-lookup');
 
 const { isEmptyDir, formatTargetDir, emptyDir } = require('../utils/index');
-const { TEMPLATES } = require('../../constants');
+const { TEMPLATES, FERT_CONFIG_FILENAME } = require('../../constants');
 
 const cwd = process.cwd();
 const templateList = TEMPLATES.map((i) => i.name);
 
 module.exports = async (root, options = {}) => {
+  throw new Error('TODO: init new monorepo template');
   const defaultProjectName = 'madgex-{cpid}';
   const argTargetDir = root ? formatTargetDir(root) : null;
   const argTemplate = options.template;
@@ -184,10 +186,13 @@ module.exports = async (root, options = {}) => {
 
   // create fert.config.js
   const fertConfigJs = fs.readFileSync(
-    path.join(outDir, 'fert.config.js'),
+    path.join(outDir, FERT_CONFIG_FILENAME),
     'utf-8'
   );
-  write('fert.config.js', fertConfigJs.replace(/{CPID}/gi, clientPropertyId));
+  write(
+    FERT_CONFIG_FILENAME,
+    fertConfigJs.replace(/{CPID}/gi, clientPropertyId)
+  );
 
   const cdProjectName = path.relative(cwd, outDir);
 

package/bin/commands/publish-tasks/get-aws-parameter.js

@@ -1,5 +1,4 @@
 const { SSMClient, GetParameterCommand } = require('@aws-sdk/client-ssm');
-const { fromEnv } = require('@aws-sdk/credential-providers');
 const { AWS_REGION } = require('../../../constants');
 
 /**
@@ -17,7 +16,6 @@ const { AWS_REGION } = require('../../../constants');
 const getAwsParam = async (paramName) => {
   const client = new SSMClient({
     region: AWS_REGION,
-    credentials: fromEnv(),
   });
   const input = {
     Name: paramName,
@@ -32,7 +30,7 @@ const getAwsParam = async (paramName) => {
     result = response.Parameter.Value;
   } catch (error) {
     console.log(`parameter-store error (${paramName}) ${error.message}`, error);
-    process.exit(1);
+    throw error;
   }
 
   return result;

package/bin/commands/publish.js

@@ -5,7 +5,10 @@ const { resolveConfig } = require('../utils');
 const { log } = require('../utils/logging');
 const getAwsParam = require('./publish-tasks/get-aws-parameter');
 const AssetStoreUploader = require('./publish-tasks/asset-store-uploader');
-const { updateProjectConfigs } = require('../utils/configs.js');
+const {
+  updateProjectConfigs,
+  validateLocalConfigs,
+} = require('../utils/configs.js');
 const {
   getCloudFrontDistributionsForDomain,
 } = require('../utils/lookup-cf-distribution-ids');
@@ -18,8 +21,8 @@ const {
   BRANDED_SITE_INVALIDATION_PATH,
 } = require('../../constants');
 
-module.exports = async (root, options) => {
-  const fertConfig = await resolveConfig(root, options);
+module.exports = async (options) => {
+  const fertConfig = await resolveConfig(options);
   const validTargets = ['dev', 'prod'];
 
   if (!validTargets.includes(options.target)) {
@@ -28,6 +31,10 @@ module.exports = async (root, options) => {
     );
   }
 
+  if (options.dryRun) {
+    console.log(chalk.green('Running Publish in Dry Mode'));
+  }
+
   const templateCtx = {
     env: options.target === 'prod' ? 'job' : 'jb.dev',
     Environment_Name: options.target === 'prod' ? 'production' : 'dev',
@@ -71,15 +78,26 @@ module.exports = async (root, options) => {
       basePath: remoteBasePath,
     });
 
-    const uploadResult = await assetStore.uploadDir(localDir);
-
+    let uploadResult;
+    if (!options.dryRun) {
+      uploadResult = await assetStore.uploadDir(localDir);
+    }
     // validate & upload local configs to configuration API
-    await updateProjectConfigs(fertConfig, {
-      environment: fertConfig.currBranch === 'master' ? 'production' : 'dev',
-    });
+    if (!options.dryRun) {
+      await updateProjectConfigs({
+        workingDir: fertConfig.rootDir,
+        clientPropertyId: fertConfig.clientPropertyId,
+        environment: fertConfig.currBranch === 'master' ? 'production' : 'dev',
+      });
+    } else {
+      await validateLocalConfigs({
+        workingDir: fertConfig.rootDir,
+        clientPropertyId: fertConfig.clientPropertyId,
+      });
+    }
 
     log.success(
-      `Publish complete in ${(uploadResult.duration / 1000).toFixed(0)}s\n`
+      `Publish complete in ${((uploadResult?.duration || 1) / 1000).toFixed(0)}s\n`
     );
 
     // invalidate cloudfront cache

package/bin/utils/configs.js

@@ -9,17 +9,23 @@ const { CONFIG_DIR } = require('../../constants');
 /**
  * Validates the local configuration files against the provided schema.
  *
- * @param {Object} fertConfig - The project config.
- * @param {Object} options - The options object.
- * @param {boolean} options.catch - Whether to catch validation errors or just log them.
+ * @param {Object} options - required, The options object.
+ * @param {string} options.workingDir - required, Working dir for configs - should usually be 'root' where fert.config.js is
+ * @param {string} options.clientPropertyId - required, clientPropertyId
+ * @param {boolean} options.throwable -  default: true, Whether to throw validation errors or just log them.
  *
  * @returns {Promise<void>} - Returns a promise that resolves if all configurations are valid.
  * @throws {Error} - Throws an error if any configuration is invalid.
  */
-const validateLocalConfigs = async (fertConfig, options = { catch: true }) => {
-  Hoek.assert(fertConfig, 'fertConfig is required');
+const validateLocalConfigs = async ({
+  workingDir,
+  clientPropertyId,
+  throwable = true,
+}) => {
+  Hoek.assert(clientPropertyId, 'clientPropertyId is required');
+  Hoek.assert(workingDir, 'workingDir is required');
 
-  const dir = path.join(fertConfig.workingDir, CONFIG_DIR);
+  const dir = path.join(workingDir, CONFIG_DIR);
   if (!fs.existsSync(dir)) {
     log.debug(`Directory does not exist: ${dir}`);
 
@@ -27,9 +33,9 @@ const validateLocalConfigs = async (fertConfig, options = { catch: true }) => {
   }
 
   const api = await getConfigAPI({
-    clientPropertyId: fertConfig.clientPropertyId,
+    clientPropertyId,
   });
-  const localConfigs = loadLocalConfigs(fertConfig);
+  const localConfigs = loadLocalConfigs(workingDir);
 
   const validationPromises = Object.keys(localConfigs).map(
     async (configName) => {
@@ -66,7 +72,7 @@ const validateLocalConfigs = async (fertConfig, options = { catch: true }) => {
       } catch (err) {
         log.error(err.message);
 
-        if (!options.catch) {
+        if (throwable) {
           throw err;
         }
       }
@@ -92,8 +98,14 @@ const getConfigAPI = async ({
   return api;
 };
 
-const loadLocalConfigs = (fertConfig) => {
-  const dir = path.join(fertConfig.workingDir, CONFIG_DIR);
+/**
+ * loading all configs from a directory (usually root /configs folder)
+ *
+ * @param {string} workingDir
+ * @returns {Promise<Object>} - Object map of configs loaded from files {filename:configJSON,...}
+ */
+const loadLocalConfigs = (workingDir) => {
+  const dir = path.join(workingDir, CONFIG_DIR);
   const configs = {};
   const files = fs.readdirSync(dir);
 
@@ -125,17 +137,22 @@ const loadLocalConfigs = (fertConfig) => {
 /**
  * Handles the removal and setting of project configs in the Configuration API.
  *
- * @param {Object} fertConfig - The project config.
+ * @param {Object} options - required, The options object.
+ * @param {string} options.workingDir - required, Working dir for configs - should usually be 'root' where fert.config.js is
+ * @param {string} options.clientPropertyId - required, clientPropertyId
+ * @param {string} options.environment - default=production, clientPropertyId
  *
  * @returns {Promise<boolean>} - Returns a promise that resolves to true if the update is successful.
  */
-const updateProjectConfigs = async (
-  fertConfig,
-  { environment = 'production' } = {}
-) => {
-  Hoek.assert(fertConfig, 'fertConfig is required');
+const updateProjectConfigs = async ({
+  clientPropertyId,
+  workingDir,
+  environment = 'production',
+} = {}) => {
+  Hoek.assert(clientPropertyId, 'clientPropertyId is required');
+  Hoek.assert(workingDir, 'workingDir is required');
 
-  const dir = path.join(fertConfig.workingDir, CONFIG_DIR);
+  const dir = path.join(workingDir, CONFIG_DIR);
   let spinner;
 
   if (!fs.existsSync(dir)) {
@@ -145,15 +162,11 @@ const updateProjectConfigs = async (
   }
 
   try {
-    await validateLocalConfigs(fertConfig, { catch: false });
-
-    const api = await getConfigAPI({
-      clientPropertyId: fertConfig.clientPropertyId,
-      environment,
-    });
+    await validateLocalConfigs({ clientPropertyId, workingDir });
+    const api = await getConfigAPI({ clientPropertyId, environment });
     spinner = ora('Fetching local configs').start();
 
-    const localConfigs = loadLocalConfigs(fertConfig);
+    const localConfigs = loadLocalConfigs(workingDir);
     const { toRemove, toSet } = collateConfigs(api, localConfigs);
 
     spinner.text = 'Updating configs…';
@@ -227,13 +240,12 @@ const getUnsetKeysWithDefaults = (defaults = {}, config = {}) => {
   return diff;
 };
 
-const removeConfigs = async (api, toRemove, spinner) => {
+const removeConfigs = async (api, toRemove) => {
   const deletePromises = Object.entries(toRemove).flatMap(
     ([configName, keys]) =>
       keys.map(async (key) => {
         try {
           await api.deleteConfig(configName, key);
-          spinner.text = `Removed key ${chalk.bold(key)} from config: ${chalk.bold(configName)}`;
         } catch (error) {
           log.error('Failed to remove config', { configName, key, error });
         }
@@ -243,12 +255,11 @@ const removeConfigs = async (api, toRemove, spinner) => {
   await Promise.all(deletePromises);
 };
 
-const setConfigs = async (api, toSet, spinner) => {
+const setConfigs = async (api, toSet) => {
   const setPromises = Object.entries(toSet).flatMap(([configName, config]) =>
     Object.entries(config).map(async ([key, value]) => {
       try {
         await api.setConfig(configName, key, value);
-        spinner.text = `Set key ${chalk.bold(key)} for config: ${chalk.bold(configName)}`;
       } catch (error) {
         log.error('Failed to set config', { configName, key, value, error });
       }

package/bin/utils/configs.test.js

@@ -9,10 +9,14 @@ describe('configs', () => {
     it('logs debug message if config directory does not exist', async (t) => {
       const fsSpy = t.mock.method(fs, 'existsSync');
       const logSpy = t.mock.method(log, 'debug');
-      const fertConfig = { workingDir: '/non/existent/dir' };
+      const workingDir = '/non/existent/dir';
+      const clientPropertyId = 'cpid';
       let calls;
 
-      await validateLocalConfigs(fertConfig);
+      await validateLocalConfigs({
+        workingDir,
+        clientPropertyId,
+      });
 
       calls = fsSpy.mock.calls;
       assert.strictEqual(calls[0].arguments[0], '/non/existent/dir/config');
@@ -28,10 +32,14 @@ describe('configs', () => {
     it('logs debug message if config directory does not exist', async (t) => {
       const fsSpy = t.mock.method(fs, 'existsSync');
       const logSpy = t.mock.method(log, 'debug');
-      const fertConfig = { workingDir: '/non/existent/dir' };
+      const workingDir = '/non/existent/dir';
+      const clientPropertyId = 'cpid';
       let calls;
 
-      await updateProjectConfigs(fertConfig);
+      await updateProjectConfigs({
+        workingDir,
+        clientPropertyId,
+      });
 
       calls = fsSpy.mock.calls;
       assert.strictEqual(calls[0].arguments[0], '/non/existent/dir/config');

package/bin/utils/cpid-matches-git-remote.js

@@ -2,6 +2,7 @@ const simpleGit = require('simple-git');
 const chalk = require('chalk');
 const Hoek = require('@hapi/hoek');
 const dedent = require('dedent');
+const utils = require('./index.js');
 
 /**
  * Validates client property ID found in the fert config against the git url and the package name.
@@ -17,13 +18,18 @@ const dedent = require('dedent');
  *
  */
 
-exports.cpIdMatchesGitRemote = async (fertConfig, workingDir) => {
-  // Validate that the working directory is a git repository
+exports.cpIdMatchesGitRemote = async (fertConfig) => {
+  const fertConfigDir = await utils.findFertConfigDir();
+
+  // Validate that the fert config directory is a git repository
   const simpleGitOptions = {
     baseDir: fertConfig.workingDir,
   };
   const git = simpleGit(simpleGitOptions);
-  Hoek.assert(await git.checkIsRepo(), `${workingDir} is not a git repository`);
+  Hoek.assert(
+    await git.checkIsRepo(),
+    `detected fert config in${fertConfigDir}, but it is not a git repository`
+  );
 
   // Validate that the CPID in the fert config matches the CPID in the git remote URL
   try {

package/bin/utils/index.js

@@ -1,6 +1,11 @@
 const path = require('node:path');
 const fs = require('node:fs');
-const { VERSION, SITE } = require('../../constants');
+const { glob } = require('node:fs/promises');
+const {
+  VERSION,
+  FERT_CONFIG_FILENAME,
+  FERT_SERVICE_CONFIG_FILENAME,
+} = require('../../constants');
 const chalk = require('chalk');
 const uuidValidator = require('uuid-validate');
 const Hoek = require('@hapi/hoek');
@@ -31,9 +36,10 @@ exports.getConfig = async (cpid, configNames = []) => {
   return result;
 };
 
-exports.resolveConfig = async (root, options = {}) => {
+exports.resolveConfig = async (options = {}) => {
   const defaults = {
     clientPropertyId: null,
+    serviceName: null,
     entry: 'src/index.js',
     externalAssets: {
       links: [],
@@ -41,12 +47,22 @@ exports.resolveConfig = async (root, options = {}) => {
     },
   };
 
-  const workingDir = root ? path.resolve(root) : path.resolve(process.cwd());
-  const git = simpleGit({ baseDir: workingDir });
+  const rootDir = await this.findFertConfigDir();
+  const git = simpleGit({ baseDir: rootDir });
 
+  const serviceConfigs = await this.loadServiceConfigFiles();
+
+  // workingDir based on service folder
+  const { dir: workingDir, serviceConfig } = serviceConfigs.find(
+    (item) => item.serviceConfig.serviceName === options.serviceName
+  );
   const fertConfig = Hoek.applyToDefaults(
     defaults,
-    this.loadConfigFromFile(workingDir)
+    // merge fert config  with service config
+    {
+      ...this.loadConfigFromFile({ dir: rootDir }),
+      ...serviceConfig,
+    }
   );
 
   // Check Fert cpid is valid
@@ -55,14 +71,16 @@ exports.resolveConfig = async (root, options = {}) => {
     `Invalid clientPropertyId specified in fert.config.js: ${fertConfig.clientPropertyId}`
   );
 
+  // Check Fert serviceName is valid
+  Hoek.assert(
+    typeof fertConfig.serviceName === 'string',
+    `serviceName required: ${fertConfig.serviceName}`
+  );
   // get & store the current git branch
   fertConfig.currBranch = (await git.branch()).current;
 
   // Check Fert cpid matches git's remote
-  const fertCpidMatchesGitRemote = await cpIdMatchesGitRemote(
-    fertConfig,
-    workingDir
-  );
+  const fertCpidMatchesGitRemote = await cpIdMatchesGitRemote(fertConfig);
 
   Hoek.assert(
     fertCpidMatchesGitRemote,
@@ -78,11 +96,9 @@ exports.resolveConfig = async (root, options = {}) => {
     // 'SiteName',
   ]);
 
-  fertConfig.assumeSite =
-    SITE[options.assumeSite] || SITE[fertConfig.assumeSite] || SITE.js;
-
   return {
     ...fertConfig,
+    rootDir,
     workingDir,
     cli: {
       ...options,
@@ -91,9 +107,48 @@ exports.resolveConfig = async (root, options = {}) => {
   };
 };
 
-exports.loadConfigFromFile = (workingDir) => {
-  const configPath = path.resolve(workingDir, 'fert.config.js');
+/**
+ * Find the root fert config in this project. This is required to
+ * determine where our 'root' is for the project even if you're inside a service folder.
+ *
+ * @returns {string} closest fert config directory in this folder, or above
+ */
+exports.findFertConfigDir = async () => {
+  const { findUp } = await import('find-up-simple');
+  const fertConfigPath = await findUp(FERT_CONFIG_FILENAME);
+  if (!fertConfigPath) throw new Error(`couldn't find ${FERT_CONFIG_FILENAME}`);
+  return path.resolve(path.dirname(fertConfigPath));
+};
+
+/**
+ * find and load all service config files, return config and location
+ * @param {string} root directory path
+ * @returns
+ */
+exports.loadServiceConfigFiles = async () => {
+  const rootDir = await this.findFertConfigDir();
+
+  const serviceConfigs = [];
+  for await (const filePath of glob(`**/${FERT_SERVICE_CONFIG_FILENAME}`, {
+    cwd: path.resolve(rootDir),
+    exclude: (item) => ['node_modules', 'dist'].includes(item),
+  })) {
+    const dir = path.resolve(rootDir, path.dirname(filePath));
+    const serviceConfig = await this.loadConfigFromFile({
+      dir,
+      filename: FERT_SERVICE_CONFIG_FILENAME,
+    });
+    serviceConfigs.push({ dir, serviceConfig });
+  }
+  return serviceConfigs;
+};
 
+exports.loadConfigFromFile = ({
+  dir = process.cwd(),
+  filename = FERT_CONFIG_FILENAME,
+  silent = false,
+}) => {
+  const configPath = path.resolve(dir, filename);
   try {
     // always return fresh config
     if (require.cache[configPath]) {
@@ -104,13 +159,14 @@ exports.loadConfigFromFile = (workingDir) => {
 
     return fertConfig;
   } catch (err) {
-    log.error(
-      `Failed to load fert.config.js - ensure you're running fert on a branding repo & config exists.\n`
-    );
-
-    console.error(err);
+    if (!silent) {
+      log.error(
+        `Failed to load ${filename} - ensure you're running fert on a branding repo & config exists.\n`
+      );
 
-    process.exit(1);
+      console.error(err);
+      throw err;
+    }
   }
 };
 

package/constants.js

@@ -15,21 +15,40 @@ module.exports = {
   VERSION,
   TMP_DIR: fs.realpathSync(os.tmpdir()),
   FERT_PACKAGE_DIR: path.resolve('./'),
-  DEFAULT_DEV_PORT: 3000,
   AWS_REGION: 'eu-west-1',
   PROPERTY_ID_API:
     'https://property-identification-api.cs.madgexhosting.net/properties/',
   ASSETS_API_URL: 'https://asset-store.job.madgexhosting.net',
   BRAND_JSON_FILENAME: 'brand.json',
   FERT_CONFIG_FILENAME: 'fert.config.js',
+  FERT_SERVICE_CONFIG_FILENAME: 'fert.service.config.js',
   ASSET_STORE_API: 'https://asset-store-api.{env}.madgexhosting.net/',
   UPLOAD_DIR: 'dist',
-  REMOTE_UPLOAD_BASE:
-    '/api/assets/jobseekers-frontend/{fertConfig.clientPropertyId}',
+  /**
+   * use `jobseekers-frontend` AWS keys for asset-store access, even for all services (e.g. recruiterservices-frontend).
+   * 💡 Technically this should be `fert-service` key. It does not make sense to create `recruiterservices-frontend` with access too.
+   * Possibly one to refactor in the future.
+   * */
   AWS_PARAM_NAME:
     '/{Environment_Name}/jobboard/kong/internal/consumer-key/jobseekers-frontend_{fertConfig.client.rootClientPropertyId}',
-  ASSET_STORE_INVALIDATION_PATH: `/{fertConfig.client.rootClientPropertyId}/jobseekers-frontend/{fertConfig.clientPropertyId}/*`,
-  BRANDED_SITE_INVALIDATION_PATH: `/_/jobseekers-frontend/assets/*`,
+  /**
+   * important to have the correct service name and cpid so assets are uploaded to the correct unique place per-service.
+   */
+  REMOTE_UPLOAD_BASE:
+    '/api/assets/{fertConfig.serviceName}/{fertConfig.clientPropertyId}',
+  /**
+   * invalidates the real asset store key path, which is related to `REMOTE_UPLOAD_BASE`
+   * asset-store puts things in `rootClientPropertyId` based on the AWS_PARAM_NAME used, and the rest of the path relates to `REMOTE_UPLOAD_BASE`
+   */
+  ASSET_STORE_INVALIDATION_PATH: `/{fertConfig.client.rootClientPropertyId}/{fertConfig.serviceName}/{fertConfig.clientPropertyId}/*`,
+  /**
+   * cloud backend cache busting for updated assets.
+   * assumption that assets are accessed on each service via a similar root.
+   * e.g.
+   * www.bigworkbag.com/_/jobseekers-frontend/assets/my-asset.png
+   * recruiter.bigworkbag.com/_/recruiterservices-frontend/assets/my-asset.png
+   */
+  BRANDED_SITE_INVALIDATION_PATH: `/_/{fertConfig.serviceName}/assets/*`,
   ASSET_STORE_USER_GUID: 'a386d4b6-f2df-4b80-ad1f-0349e23f530b',
   TEMPLATES: [
     {
@@ -41,10 +60,6 @@ module.exports = {
       display: 'BigWorkBag - populated, example project',
     },
   ],
-  SITE: {
-    js: 'jobseekers-frontend',
-    rs: 'recruiterservices-frontend',
-  },
   ONE_MINUTE,
   ONE_HOUR,
   ONE_DAY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madgex/fert",
-  "version": "4.2.6",
+  "version": "5.0.1",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"
@@ -18,7 +18,7 @@
     "url": "https://github.com/wiley/madgex-frontend-rollout-tool.git"
   },
   "engines": {
-    "node": ">=18.20.0"
+    "node": ">=22"
   },
   "author": "Madgex",
   "license": "UNLICENSED",
@@ -31,16 +31,16 @@
     "@hapi/inert": "^7.1.0",
     "@hapi/vision": "^7.0.3",
     "@hapipal/toys": "^4.0.0",
-    "@madgex/config-api-sdk": "^1.6.1",
+    "@madgex/config-api-sdk": "^1.6.2",
     "@madgex/design-system": "^9.1.9",
     "@private/header-footer-podlet-server": "github:wiley/madgex-header-footer-podlet",
     "axios": "^1.7.9",
     "cac": "^6.7.14",
     "chalk": "4.1.2",
     "chokidar": "^3.5.3",
-    "dayjs": "^1.11.13",
     "debug": "^4.4.0",
     "dedent": "^1.5.3",
+    "find-up-simple": "^1.0.0",
     "flat-cache": "^4.0.0",
     "form-data": "^4.0.1",
     "lodash": "^4.17.21",
@@ -49,12 +49,12 @@
     "ora": "5.4.1",
     "prompts": "^2.4.2",
     "rimraf": "^5.0.5",
-    "sass": "^1.83.0",
+    "sass": "^1.83.4",
     "simple-git": "^3.27.0",
     "simple-update-notifier": "^2.0.0",
     "style-dictionary": "3.9.0",
     "uuid-validate": "^0.0.3",
-    "vite": "^4.4.9",
+    "vite": "^4.5.9",
     "vite-plugin-static-copy": "^0.17.1"
   },
   "devDependencies": {

package/repo-templates/globals/fert.config.js

@@ -1,5 +1,6 @@
 module.exports = {
   clientPropertyId: '{CPID}',
+  serviceName: null,
   entry: './src/index.js',
   externalAssets: {
     links: [],

package/repo-templates/template-basic/_gitignore

@@ -2,4 +2,5 @@
 .tmp
 node_modules
 .DS_Store
-dist
+dist
+**/public/tokens

package/repo-templates/template-bigworkbag/_gitignore

@@ -2,4 +2,5 @@
 .tmp
 node_modules
 .DS_Store
-dist
+dist
+**/public/tokens

package/server/index.js

@@ -3,17 +3,12 @@ const Toys = require('@hapipal/toys');
 const path = require('node:path');
 const { log } = require('../bin/utils/logging');
 const podletServer = require('@private/header-footer-podlet-server');
-const {
-  VERSION,
-  DEFAULT_DEV_PORT,
-  PROPERTY_ID_API,
-  ASSETS_API_URL,
-} = require('../constants');
+const { VERSION, PROPERTY_ID_API, ASSETS_API_URL } = require('../constants');
 
 exports.devServer = async ({ start, fertConfig = {} } = {}) => {
   const server = Hapi.server({
-    port: fertConfig.cli.port ?? DEFAULT_DEV_PORT,
-    host: fertConfig.cli.host ?? 'localhost',
+    port: 0, // 0 === random unused port
+    host: fertConfig.cli?.host ?? 'localhost',
   });
 
   // "the path prefix used to locate static resources (files and view templates) when relative paths are used"
@@ -40,7 +35,7 @@ exports.devServer = async ({ start, fertConfig = {} } = {}) => {
       templatePath: [path.resolve(fertConfig.workingDir, 'templates')],
       clientPropertiesApi: PROPERTY_ID_API,
       assetsApiUrl: ASSETS_API_URL,
-      layout: fertConfig.assumeSite,
+      layout: fertConfig.serviceName,
     },
     routes: { prefix: '/_podlet' },
   });
@@ -56,6 +51,7 @@ exports.devServer = async ({ start, fertConfig = {} } = {}) => {
         watch: ['/templates/**/*', '/public/tokens/**/*'].map((p) =>
           path.join(fertConfig.workingDir, p)
         ),
+        root: path.resolve(fertConfig.workingDir),
         entry: path.join(fertConfig.workingDir, fertConfig.entry),
         log: log.debug,
       },
@@ -82,7 +78,7 @@ exports.devServer = async ({ start, fertConfig = {} } = {}) => {
   });
 
   // routes
-  server.route(require('./routes/public'));
+  server.route(require('./routes/public')({ fertConfig }));
   server.route(require('./routes/views'));
   server.ext(require('./extensions/error-logging'));
 

package/server/plugins/hapi-vite.js

@@ -21,6 +21,7 @@ module.exports = {
       type: 'onPostStart',
       method: async (server) => {
         server.app.viteServer = await createServer({
+          root: options.root,
           server: {
             origin: server.info.uri,
             watch: {

package/server/routes/public.js

@@ -1,7 +1,7 @@
-module.exports = [
+module.exports = ({ fertConfig }) => [
   {
     method: 'get',
-    path: '/_/jobseekers-frontend/assets/{p*}',
+    path: `/_/${fertConfig.serviceName}/assets/{p*}`,
     handler: {
       directory: {
         path: ['./dist', './public'],

package/server/routes/views.js

@@ -16,7 +16,10 @@ module.exports = {
     const podletResponse = await request.server.inject({
       url: `/_podlet${request.path}`,
       method: request.method,
-      headers: filteredHeaders,
+      headers: {
+        ...filteredHeaders,
+        'podium-requested-by': fertConfig.serviceName,
+      },
       auth: request.auth.isAuthenticated ? request.auth : null,
       app: {
         clientPropertyId: fertConfig.clientPropertyId,

package/shared/Dockerfile.brandingRepoPublish

@@ -1,4 +1,4 @@
-FROM node:18-alpine
+FROM node:22-alpine
 
 ENV HOME=/app/