@madgex/fert 2.0.5 → 2.1.0

package/README.md

@@ -10,45 +10,41 @@ The Madgex job board brands all have a custom headers, footers and their associa
 
 ## Requirements
 
-* To be a one-stop shop for:
-  
-  * Scaffolding a new project
-  
-  * A dev server to allow easy brand development
-  
-  * Builds distributable assets
+- To be a one-stop shop for:
 
-* Must be able to install via [NPM](https://www.npmjs.com/) or internal registry
+  - Scaffolding a new project
+  - A dev server to allow easy brand development
+  - Builds distributable assets
 
-* Must work cross-platform (Windows and *nix)
+- Must be able to install via [NPM](https://www.npmjs.com/) or internal registry
+
+- Must work cross-platform (Windows and \*nix)
 
 ## A human-first design
 
 To empower & serve its users, we should design this CLI with the users in mind. Ensuring it feels as familiar as possible, following established patterns and is has the following:
 
-* Easy to learn commands from a inbuilt help screen
+- Easy to learn commands from a inbuilt help screen
 
-* Easy to read/understand error messages
+- Easy to read/understand error messages
 
-* Empathy in the error messages – can some helpful context be provided with the error to assist the user remedy the issue?
+- Empathy in the error messages – can some helpful context be provided with the error to assist the user remedy the issue?
 
 # Under the hood
 
-* [Hapi](https://hapi.dev/) is used for the local dev server
-
-* [Vite](https://vitejs.dev/) for HMR, serves the JS entry & bundles assets for production
-
-* [Style Dictionary](https://amzn.github.io/style-dictionary/#/README) is used to transform Design Tokens into various outputs, inc. JSON, CSS Custom Properties and SCSS variables. The output is built into `public/tokens/`
+- [Hapi](https://hapi.dev/) is used for the local dev server
 
-* Chokidar is used to watch for changes in the `templates` and `public/tokens` directories and either refresh the browser page or build a new set of tokens respectively.
+- [Vite](https://vitejs.dev/) for HMR, serves the JS entry & bundles assets for production
 
+- [Style Dictionary](https://amzn.github.io/style-dictionary/#/README) is used to transform Design Tokens into various outputs, inc. JSON, CSS Custom Properties and SCSS variables. The output is built into `public/tokens/`
 
+- Chokidar is used to watch for changes in the `templates` and `public/tokens` directories and either refresh the browser page or build a new set of tokens respectively.
 
 # Configuration
 
 There are **three required files** in the root of the branding repo:
 
-`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.
+`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)
 
 e.g.
 
@@ -60,7 +56,7 @@ e.g.
         "base": { "value": "#005689" }
       }
     }
-  },
+  }
   // more branding tokens applied here...
 }
 ```
@@ -71,7 +67,7 @@ e.g.
 | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
 | `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`.
+| `assumeSite` <String>       | Which site we want to display, jobseeker site or recruiter site. Values are either `js` or `rs`.                                           |
 
 The `entry` will be used by Vite to create production bundles.
 
@@ -79,9 +75,9 @@ e.g.
 
 ```js
 module.exports = {
-  clientPropertyId: "ff6102ff-0f4b-43d1-a2c7-83b835b8dee5",
-  entry: "./src/index.js",
-  assumeSite: "js",
+  clientPropertyId: 'ff6102ff-0f4b-43d1-a2c7-83b835b8dee5',
+  entry: './src/index.js',
+  assumeSite: 'js',
 };
 ```
 
@@ -91,13 +87,13 @@ module.exports = {
 
 The CLI will support 3 main commands: dev server (default command), scaffolding a new project and building production assets.
 
-* [Dev server](#dev-server)
+- [Dev server](#dev-server)
 
-* [Scaffold](#scaffold)
+- [Scaffold](#scaffold)
 
-* [Build](#build)
+- [Build](#build)
 
-* [Publish](#publish)
+- [Publish](#publish)
 
 ## Dev server
 
@@ -133,10 +129,10 @@ When faced with an empty branding repo, this will help the user get started with
 
 **Options**
 
-| Option    |                                                                       |
-| --------- | --------------------------------------------------------------------- |
-| `--template <template>` | Specify the template you wish to use when scaffolding |
-| `--cpid <cpid>` | Specify the clientPropertyId to use in the new project |
+| Option                  |                                                        |
+| ----------------------- | ------------------------------------------------------ |
+| `--template <template>` | Specify the template you wish to use when scaffolding  |
+| `--cpid <cpid>`         | Specify the clientPropertyId to use in the new project |
 
 **Outline of implementation**
 
@@ -194,7 +190,13 @@ Index all the files and their paths in the `dist` directory, and using a recursi
 
 The Asset Store API uses a multi-part form upload to PUT files in the client directory. Upload paths are respected, directories are created on the fly.
 
+# Global options
+
+These options are available no matter the command used.
+
+`--no-cache` — Do not use the in-built file-based cache. This includes CPID, config & AWS CloudFront Distribution lookup (default: true)
 
+`--purge-cache` — Purge/clean all local caches
 
 # CI/CD
 
@@ -213,4 +215,4 @@ Here are the default npm scripts in a Fert-scaffolded project.
 }
 ```
 
-Its expected that a Jenkins pipeline will run `fert publish` to send all built assets to the Asset Store API.
+Its expected that a Jenkins pipeline will run `fert publish` to send all built assets to the Asset Store API.

package/bin/cli.js

@@ -47,6 +47,8 @@ const run = () => {
     )
     .action((...args) => require('./commands/init')(...args));
 
+  cli.option('--no-cache', 'Do not use cache');
+  cli.option('--purge-cache', 'Purge all caches');
   cli.help();
   cli.version(VERSION);
   cli.parse();

package/bin/commands/init.js

@@ -104,7 +104,7 @@ module.exports = async (root, options = {}) => {
   ).start();
   let clientProperties;
   try {
-    clientProperties = await cpidLookup(clientPropertyId);
+    clientProperties = await cpidLookup(clientPropertyId, options);
     spinner.succeed(
       `Looking up clientPropertyId: ${chalk.green(clientPropertyId)}`
     );

package/bin/commands/publish-tasks/asset-store-uploader.js

@@ -81,8 +81,9 @@ module.exports = class AssetStoreUploader {
   /**
    * Invalidate files on all CloudFront edge locations
    * @param {array} paths Paths to invalidate
+   * @param {string?} distributionId CloudFront distribution id to invalidate
    */
-  async invalidatePaths(paths) {
+  async invalidatePaths(paths, distributionId = false) {
     const invalidateUrl = new URL('api/assets/invalidate', this.apiUrl);
 
     log.debug('invalidating', { paths });
@@ -92,6 +93,10 @@ module.exports = class AssetStoreUploader {
       paths,
     };
 
+    if (distributionId) {
+      payload.distributionId = distributionId;
+    }
+
     await axios.post(invalidateUrl.href, payload, {
       headers: {
         apikey: this.apiKey,
@@ -99,11 +104,9 @@ module.exports = class AssetStoreUploader {
     });
 
     log.info(
-      `CloudFront cache invalidation sent for the following paths:\n${JSON.stringify(
-        paths
-      )}\n\nNote this may take upto ${chalk.yellow(
-        '30 seconds'
-      )} to complete.\n`
+      `CloudFront cache invalidation sent for the following paths${
+        distributionId ? ` (distribution id: ${distributionId})` : ''
+      }:\n${JSON.stringify(paths)}\n`
     );
   }
   // Returns array of all files in provided directory (recursive)

package/bin/commands/publish.js

@@ -5,12 +5,16 @@ 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 {
+  getCloudFrontDistributionsForDomain,
+} = require('../utils/lookup-cf-distribution-ids');
 const {
   ASSET_STORE_API,
   AWS_PARAM_NAME,
   REMOTE_UPLOAD_BASE,
   UPLOAD_DIR,
-  INVALIDATION_PATH,
+  ASSET_STORE_INVALIDATION_PATH,
+  BRANDED_SITE_INVALIDATION_PATH,
 } = require('../../constants');
 
 module.exports = async (root, options) => {
@@ -33,10 +37,23 @@ module.exports = async (root, options) => {
   const apiUrl = Hoek.reachTemplate(templateCtx, ASSET_STORE_API);
   const remoteBasePath = Hoek.reachTemplate(templateCtx, REMOTE_UPLOAD_BASE);
   const apiKeyParamPath = Hoek.reachTemplate(templateCtx, AWS_PARAM_NAME);
-  const invalidationPath = Hoek.reachTemplate(templateCtx, INVALIDATION_PATH);
+  const assetStoreInvPath = Hoek.reachTemplate(
+    templateCtx,
+    ASSET_STORE_INVALIDATION_PATH
+  );
+  const brandedSiteInvPath = Hoek.reachTemplate(
+    templateCtx,
+    BRANDED_SITE_INVALIDATION_PATH
+  );
 
   const apiKey = await getAwsParam(apiKeyParamPath);
 
+  const siteUrl = new URL(fertConfig.config.JobseekerSiteWebSitePath);
+  const clientCloudFrontDists = await getCloudFrontDistributionsForDomain(
+    siteUrl.hostname,
+    options
+  );
+
   log.info(
     `\nPublishing ${chalk.cyan(localDir)} to ${chalk.green.bold(
       options.target
@@ -52,9 +69,22 @@ module.exports = async (root, options) => {
     basePath: remoteBasePath,
   });
 
-  const result = await assetStore.uploadDir(localDir);
+  const uploadResult = await assetStore.uploadDir(localDir);
 
-  log.success(`Publish complete in ${(result.duration / 1000).toFixed(0)}s\n`);
+  log.success(
+    `Publish complete in ${(uploadResult.duration / 1000).toFixed(0)}s\n`
+  );
 
-  await assetStore.invalidatePaths([invalidationPath]);
+  // invalidate cloudfront cache
+  await assetStore.invalidatePaths([assetStoreInvPath]);
+
+  for (let dist of clientCloudFrontDists) {
+    await assetStore.invalidatePaths([brandedSiteInvPath], dist.id);
+  }
+
+  log.info(
+    `\nNote cloudfront invalidations may take upto ${chalk.yellow(
+      '30 seconds'
+    )} to complete.\n`
+  );
 };

package/bin/utils/cpid-lookup.js

@@ -1,23 +1,11 @@
-const path = require('node:path');
 const axios = require('axios');
 const { log } = require('../utils/logging');
-const { slug } = require('../utils/slug');
-const dayjs = require('dayjs');
-const duration = require('dayjs/plugin/duration');
-const { PROPERTY_ID_API, TMP_DIR, VERSION } = require('../../constants');
+const { PROPERTY_ID_API, ONE_WEEK } = require('../../constants');
 const chalk = require('chalk');
-const flatCache = require('flat-cache');
-const { diskCacheWithTtl } = require('./disk-cache-with-ttl');
+const { persistentCacheWithTtl } = require('./persistent-cache-with-ttl');
 
-dayjs.extend(duration);
-
-const flatCacheDoc = flatCache.load(
-  'fert-cpid-cache',
-  path.resolve(`${TMP_DIR}/fert-cpid-cache-${slug(VERSION)}`)
-);
-
-const cache = new diskCacheWithTtl(flatCacheDoc, {
-  ttl: dayjs.duration(1, 'week').asMilliseconds(),
+const cache = new persistentCacheWithTtl('cpid-cache', {
+  ttl: ONE_WEEK,
 });
 
 exports.doCpidLookup = async (clientPropertyId) => {
@@ -48,7 +36,15 @@ exports.doCpidLookup = async (clientPropertyId) => {
   };
 };
 
-exports.cpidLookup = async (clientPropertyId) => {
+exports.cpidLookup = async (clientPropertyId, options = {}) => {
+  if (options.purgeCache) {
+    cache.purgeCacheFile();
+  }
+
+  if (!options.cache) {
+    return this.doCpidLookup(clientPropertyId);
+  }
+
   const value = cache.get(clientPropertyId);
 
   if (value) {

package/bin/utils/index.js

@@ -5,13 +5,31 @@ const chalk = require('chalk');
 const uuidValidator = require('uuid-validate');
 const Hoek = require('@hapi/hoek');
 const { cpidLookup } = require('./cpid-lookup');
-const resolveExternalAssets = require('./resolve-external-assets');
+const { resolveExternalAssets } = require('./resolve-external-assets');
 const { log } = require('./logging');
+const { CONFIG_API } = require('../../constants');
+const assert = require('node:assert');
 
 exports.printBanner = () => {
   console.log(`\n${chalk.green.bold('Fert')} v${VERSION}`);
 };
 
+exports.getConfig = async (cpid, configNames = []) => {
+  assert(Array.isArray(configNames), 'configNames must be an array');
+
+  const result = {};
+
+  for (let config of configNames) {
+    const url = CONFIG_API.replace('{cpid}', cpid).replace('{config}', config);
+    const { data } = await fetch(url).then((response) => response.json());
+    const { value } = data[0];
+
+    result[config] = value;
+  }
+
+  return result;
+};
+
 exports.resolveConfig = async (root, options = {}) => {
   const defaults = {
     clientPropertyId: null,
@@ -27,7 +45,7 @@ exports.resolveConfig = async (root, options = {}) => {
     defaults,
     this.loadConfigFromFile(workingDir)
   );
-  const client = await cpidLookup(fertConfig.clientPropertyId);
+  const client = await cpidLookup(fertConfig.clientPropertyId, options);
 
   Hoek.assert(
     uuidValidator(fertConfig.clientPropertyId),
@@ -36,6 +54,11 @@ exports.resolveConfig = async (root, options = {}) => {
 
   fertConfig.externalAssets = resolveExternalAssets(fertConfig.externalAssets);
 
+  fertConfig.config = await exports.getConfig(fertConfig.clientPropertyId, [
+    'JobseekerSiteWebSitePath',
+    // 'SiteName',
+  ]);
+
   fertConfig.assumeSite =
     SITE[options.assumeSite] || SITE[fertConfig.assumeSite] || SITE.js;
 

package/bin/utils/lookup-cf-distribution-ids.js

@@ -0,0 +1,84 @@
+const {
+  CloudFrontClient,
+  ListDistributionsCommand,
+} = require('@aws-sdk/client-cloudfront');
+const { persistentCacheWithTtl } = require('./persistent-cache-with-ttl');
+const assert = require('node:assert');
+const { ONE_WEEK } = require('../../constants');
+const { log } = require('../utils/logging');
+
+const cache = new persistentCacheWithTtl('cf-distribution-cache', {
+  ttl: ONE_WEEK,
+});
+
+exports.doGetAllCloudFrontDistributions = async () => {
+  const cloudfront = new CloudFrontClient();
+  const distributions = [];
+
+  let Marker = '';
+  let isTruncated = false;
+
+  do {
+    const list = await cloudfront.send(
+      new ListDistributionsCommand({ Marker })
+    );
+
+    Marker = list.DistributionList.NextMarker;
+    isTruncated = list.DistributionList.IsTruncated;
+
+    list.DistributionList.Items.forEach((item) => distributions.push(item));
+  } while (isTruncated);
+
+  return distributions;
+};
+
+exports.getAllCloudFrontDistributions = async (options = {}) => {
+  assert(options.target, 'Target required');
+  const CACHE_KEY = `cf-distributions:${options.target}`;
+
+  if (options.purgeCache) {
+    cache.purgeCacheFile();
+  }
+
+  if (!options.cache) {
+    return this.doGetAllCloudFrontDistributions();
+  }
+
+  const value = cache.get(CACHE_KEY);
+
+  if (value) {
+    return value;
+  }
+
+  log.info('\nRefreshing CloudFront Distributions cache…');
+
+  const result = await this.doGetAllCloudFrontDistributions();
+
+  cache.set(CACHE_KEY, result);
+
+  log.success('Completed refreshing CF distribution cache.\n');
+
+  return result;
+};
+
+/**
+ * Find all CloudFront distribution Ids that are associated with the supplied domain.
+ * @param {string} domain Search all CloudFront Distributions for those that match domain name.
+ * @returns {Promise<Array.<{id:string, aliases:[string]}>>} An array of objects.
+ */
+exports.getCloudFrontDistributionsForDomain = async (domain, options) => {
+  assert(domain && typeof domain === 'string', 'Domain name required');
+
+  const distributions = await this.getAllCloudFrontDistributions(options);
+
+  return distributions.reduce((accum, val) => {
+    const { Id, Aliases } = val;
+    const { Items = [] } = Aliases;
+
+    if (Items.find((i) => i.toLowerCase().includes(domain))) {
+      accum.push({ id: Id, aliases: Items });
+    }
+
+    return accum;
+  }, []);
+};

package/bin/utils/persistent-cache-with-ttl.js

@@ -0,0 +1,49 @@
+const path = require('node:path');
+const flatCache = require('flat-cache');
+const { TMP_DIR, VERSION } = require('../../constants');
+const { slug } = require('./slug');
+const assert = require('node:assert');
+
+class persistentCacheWithTtl {
+  constructor(name, options = { ttl: 0 }) {
+    assert(name, 'Cache name required');
+
+    this.name = name;
+    this.cacheDir = path.resolve(`${TMP_DIR}/fert-${slug(VERSION)}`);
+    this.cache = this._loadCache();
+
+    this.options = options;
+  }
+
+  _loadCache() {
+    return flatCache.load(this.name, this.cacheDir);
+  }
+
+  set(key, value) {
+    this.cache.setKey(key, {
+      value,
+      expire: new Date().getTime() + this.options.ttl,
+    });
+
+    this.cache.save(true);
+  }
+
+  get(key) {
+    let cachedBlob = this.cache.getKey(key);
+
+    if (cachedBlob && new Date().getTime() > cachedBlob.expire) {
+      this.cache.removeKey(key);
+      cachedBlob = null;
+
+      this.cache.save(true);
+    }
+
+    return (cachedBlob && cachedBlob.value) || null;
+  }
+
+  purgeCacheFile() {
+    flatCache.clearCacheById(this.name, this.cacheDir);
+    this.cache = this._loadCache();
+  }
+}
+exports.persistentCacheWithTtl = persistentCacheWithTtl;

package/bin/utils/persistent-cache-with-ttl.test.js

@@ -0,0 +1,42 @@
+const { describe, it, beforeEach } = require('node:test');
+const assert = require('node:assert');
+const { persistentCacheWithTtl } = require('./persistent-cache-with-ttl');
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe('persistentCacheWithTtl', function () {
+  let cache;
+
+  beforeEach(function () {
+    cache = new persistentCacheWithTtl('test', { ttl: 5000 }); // 5 seconds ttl
+  });
+
+  it('should throw an error if no name is provided', function () {
+    assert.throws(() => new persistentCacheWithTtl(), /Cache name required/);
+  });
+
+  it('should set a value in the cache', function () {
+    cache.set('key', 'value');
+    const cachedValue = cache.get('key');
+    assert.equal(cachedValue, 'value');
+  });
+
+  it('should return null if the key does not exist', function () {
+    const cachedValue = cache.get('nonexistent');
+    assert.equal(cachedValue, null);
+  });
+
+  it('should remove a value from the cache after its ttl has expired', async function () {
+    cache = new persistentCacheWithTtl('test', { ttl: 1000 }); // 1 second ttl
+    cache.set('key', 'value');
+    await sleep(1500);
+    const cachedValue = cache.get('key');
+    assert.equal(cachedValue, null);
+  });
+
+  it('should purge the cache file', function () {
+    cache.set('key', 'value');
+    cache.purgeCacheFile();
+    const cachedValue = cache.get('key');
+    assert.equal(cachedValue, null);
+  });
+});

package/bin/utils/resolve-external-assets.js

@@ -55,23 +55,35 @@ class ScriptAsset {
   }
 }
 
-module.exports = function resolveExternalAssets(assets = {}) {
+function resolveExternalAssets(assets = {}) {
   const result = {
     links: [],
     scripts: [],
   };
 
-  const links = Array.isArray(assets.links) ? assets.links : [assets.links];
-  links.forEach((item) => {
-    result.links.push(new LinkAsset(item));
-  });
+  if (assets.links) {
+    const linkArr = Array.isArray(assets.links) ? assets.links : [assets.links];
 
-  const scripts = Array.isArray(assets.scripts)
-    ? assets.scripts
-    : [assets.scripts];
-  scripts.forEach((item) => {
-    result.scripts.push(new ScriptAsset(item));
-  });
+    linkArr.forEach((item) => {
+      result.links.push(new LinkAsset(item));
+    });
+  }
+
+  if (assets.scripts) {
+    const scriptArr = Array.isArray(assets.scripts)
+      ? assets.scripts
+      : [assets.scripts];
+
+    scriptArr.forEach((item) => {
+      result.scripts.push(new ScriptAsset(item));
+    });
+  }
 
   return result;
+}
+
+module.exports = {
+  LinkAsset,
+  ScriptAsset,
+  resolveExternalAssets,
 };

package/bin/utils/resolve-external-assets.test.js

@@ -0,0 +1,98 @@
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const {
+  LinkAsset,
+  ScriptAsset,
+  resolveExternalAssets,
+} = require('./resolve-external-assets');
+
+describe('LinkAsset', function () {
+  it('should create a LinkAsset with href when string is passed', function () {
+    const linkAsset = new LinkAsset('http://example.com');
+    assert.strictEqual(linkAsset.href, 'http://example.com');
+  });
+
+  it('should create a LinkAsset with properties when object is passed', function () {
+    const linkAsset = new LinkAsset({
+      href: 'http://example.com',
+      rel: 'preload',
+    });
+    assert.strictEqual(linkAsset.href, 'http://example.com');
+    assert.strictEqual(linkAsset.rel, 'preload');
+  });
+
+  it('should throw error when object without href is passed', function () {
+    assert.throws(
+      () => new LinkAsset({ rel: 'preload' }),
+      /missing the href property/
+    );
+  });
+
+  it('should throw error when neither string nor object is passed', function () {
+    assert.throws(() => new LinkAsset(123), /should be a string or an object/);
+  });
+});
+
+describe('ScriptAsset', function () {
+  it('should create a ScriptAsset with src when string is passed', function () {
+    const scriptAsset = new ScriptAsset('http://example.com/script.js');
+    assert.strictEqual(scriptAsset.src, 'http://example.com/script.js');
+  });
+
+  it('should create a ScriptAsset with properties when object is passed', function () {
+    const scriptAsset = new ScriptAsset({
+      src: 'http://example.com/script.js',
+      async: false,
+    });
+    assert.strictEqual(scriptAsset.src, 'http://example.com/script.js');
+    assert.strictEqual(scriptAsset.async, undefined);
+  });
+
+  it('should throw error when object without src is passed', function () {
+    assert.throws(
+      () => new ScriptAsset({ async: false }),
+      /missing the src property/
+    );
+  });
+
+  it('should throw error when neither string nor object is passed', function () {
+    assert.throws(
+      () => new ScriptAsset(123),
+      /should be a string or an object/
+    );
+  });
+});
+
+describe('resolveExternalAssets', function () {
+  it('should resolve links and scripts from assets', function () {
+    const assets = {
+      links: [
+        'http://example.com/style.css',
+        { href: 'http://example.com/style2.css', rel: 'preload' },
+      ],
+      scripts: [
+        'http://example.com/script.js',
+        { src: 'http://example.com/script2.js', async: false },
+      ],
+    };
+    const result = resolveExternalAssets(assets);
+    assert.strictEqual(result.links.length, 2);
+    assert.strictEqual(result.scripts.length, 2);
+  });
+
+  it('should handle single link and script in assets', function () {
+    const assets = {
+      links: 'http://example.com/style.css',
+      scripts: 'http://example.com/script.js',
+    };
+    const result = resolveExternalAssets(assets);
+    assert.strictEqual(result.links.length, 1);
+    assert.strictEqual(result.scripts.length, 1);
+  });
+
+  it('should handle empty assets', function () {
+    const result = resolveExternalAssets({});
+    assert.strictEqual(result.links.length, 0);
+    assert.strictEqual(result.scripts.length, 0);
+  });
+});

package/constants.js

@@ -6,6 +6,11 @@ const { version: VERSION } = JSON.parse(
   fs.readFileSync(path.resolve(__dirname, './package.json')).toString()
 );
 
+const ONE_MINUTE = 60000;
+const ONE_HOUR = ONE_MINUTE * 60;
+const ONE_DAY = ONE_HOUR * 24;
+const ONE_WEEK = ONE_DAY * 7;
+
 module.exports = {
   VERSION,
   TMP_DIR: fs.realpathSync(os.tmpdir()),
@@ -23,7 +28,8 @@ module.exports = {
     '/api/assets/jobseekers-frontend/{fertConfig.clientPropertyId}',
   AWS_PARAM_NAME:
     '/{Environment_Name}/jobboard/kong/internal/consumer-key/jobseekers-frontend_{fertConfig.client.rootClientPropertyId}',
-  INVALIDATION_PATH: `/{fertConfig.client.rootClientPropertyId}/jobseekers-frontend/{fertConfig.clientPropertyId}/*`,
+  ASSET_STORE_INVALIDATION_PATH: `/{fertConfig.client.rootClientPropertyId}/jobseekers-frontend/{fertConfig.clientPropertyId}/*`,
+  BRANDED_SITE_INVALIDATION_PATH: `/_/jobseekers-frontend/assets/*`,
   ASSET_STORE_USER_GUID: 'a386d4b6-f2df-4b80-ad1f-0349e23f530b',
   TEMPLATES: [
     {
@@ -39,4 +45,10 @@ module.exports = {
     js: 'jobseekers-frontend',
     rs: 'recruiterservices-frontend',
   },
+  ONE_MINUTE,
+  ONE_HOUR,
+  ONE_DAY,
+  ONE_WEEK,
+  CONFIG_API:
+    'https://configuration-api.job.madgexhosting.net/configs/override/{cpid}/production/clientconfig/{config}',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madgex/fert",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"
@@ -23,8 +23,9 @@
   "author": "Madgex",
   "license": "UNLICENSED",
   "dependencies": {
-    "@aws-sdk/client-ssm": "^3.453.0",
-    "@aws-sdk/credential-providers": "^3.451.0",
+    "@aws-sdk/client-cloudfront": "^3.515.0",
+    "@aws-sdk/client-ssm": "^3.519.0",
+    "@aws-sdk/credential-providers": "^3.515.0",
     "@hapi/hapi": "^21.3.2",
     "@hapi/hoek": "^11.0.2",
     "@hapi/inert": "^7.1.0",

package/bin/utils/disk-cache-with-ttl.js

@@ -1,29 +0,0 @@
-class diskCacheWithTtl {
-  constructor(cache, options = { ttl: 0 }) {
-    this.cache = cache;
-    this.options = options;
-  }
-
-  set(key, value) {
-    this.cache.setKey(key, {
-      value,
-      expire: new Date().getTime() + this.options.ttl,
-    });
-
-    this.cache.save(true);
-  }
-
-  get(key) {
-    let cachedBlob = this.cache.getKey(key);
-
-    if (cachedBlob && new Date().getTime() > cachedBlob.expire) {
-      this.cache.removeKey(key);
-      cachedBlob = null;
-
-      this.cache.save(true);
-    }
-
-    return cachedBlob && cachedBlob.value;
-  }
-}
-exports.diskCacheWithTtl = diskCacheWithTtl;