@madgex/fert 6.0.1 → 6.0.2

package/bin/utils/configs.js

@@ -1,9 +1,12 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const Hoek = require('@hapi/hoek');
-const { log } = require('../utils/logging');
-const chalk = require('chalk');
-const { CONFIG_DIR } = require('../../constants');
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+import { glob } from 'node:fs/promises';
+import path from 'node:path';
+import * as Hoek from '@hapi/hoek';
+import chalk from 'chalk';
+import { log } from '../utils/logging.js';
+import { CONFIG_DIR } from '../../constants.js';
 
 /**
  * Validates the local configuration files against the provided schema.
@@ -16,7 +19,7 @@ const { CONFIG_DIR } = require('../../constants');
  * @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 ({ workingDir, clientPropertyId, throwable = true }) => {
+export async function validateLocalConfigs({ workingDir, clientPropertyId, throwable = true }) {
   Hoek.assert(clientPropertyId, 'clientPropertyId is required');
   Hoek.assert(workingDir, 'workingDir is required');
 
@@ -30,7 +33,7 @@ const validateLocalConfigs = async ({ workingDir, clientPropertyId, throwable =
   const api = await getConfigAPI({
     clientPropertyId,
   });
-  const localConfigs = loadLocalConfigs(workingDir);
+  const localConfigs = await loadLocalConfigs(workingDir);
 
   const validationPromises = Object.keys(localConfigs).map(async (configName) => {
     try {
@@ -67,9 +70,9 @@ const validateLocalConfigs = async ({ workingDir, clientPropertyId, throwable =
   });
 
   await Promise.all(validationPromises);
-};
+}
 
-const getConfigAPI = async ({ clientPropertyId, environment = 'production' } = {}) => {
+export async function getConfigAPI({ clientPropertyId, environment = 'production' } = {}) {
   const { ConfigAPI } = await import('@madgex/config-api-sdk');
 
   const api = new ConfigAPI({
@@ -80,7 +83,7 @@ const getConfigAPI = async ({ clientPropertyId, environment = 'production' } = {
   await api.loadSchemas();
 
   return api;
-};
+}
 
 /**
  * loading all configs from a directory (usually root /configs folder)
@@ -88,35 +91,31 @@ const getConfigAPI = async ({ clientPropertyId, environment = 'production' } = {
  * @param {string} workingDir
  * @returns {Promise<Object>} - Object map of configs loaded from files {filename:configJSON,...}
  */
-const loadLocalConfigs = (workingDir) => {
+export async function loadLocalConfigs(workingDir) {
   const dir = path.join(workingDir, CONFIG_DIR);
   const configs = {};
-  const files = fs.readdirSync(dir);
-
-  files
-    .filter((file) => file.endsWith('.json'))
-    .forEach((file) => {
-      const filePath = path.join(dir, file);
-
-      if (fs.statSync(filePath).isFile()) {
-        const fileName = path.basename(file, path.extname(file));
-
-        // Purge any existing cache of the file
-        delete require.cache[filePath];
-
-        try {
-          configs[fileName] = {
-            path: filePath,
-            data: require(filePath),
-          };
-        } catch (err) {
-          log.error(`Error loading config (${filePath}): ${err.message}`);
-        }
+
+  const configFilePaths = await Array.fromAsync(glob(`*.json`, { cwd: dir }));
+
+  for (const file of configFilePaths) {
+    const filePath = path.join(dir, file);
+
+    if (fs.statSync(filePath).isFile()) {
+      const fileName = path.basename(file, path.extname(file));
+      const { default: data } = await import(pathToFileURL(filePath), { with: { type: 'json' } });
+      try {
+        configs[fileName] = {
+          path: filePath,
+          data,
+        };
+      } catch (err) {
+        log.error(`Error loading config (${filePath}): ${err.message}`);
       }
-    });
+    }
+  }
 
   return configs;
-};
+}
 
 /**
  * Handles the removal and setting of project configs in the Configuration API.
@@ -128,7 +127,7 @@ const loadLocalConfigs = (workingDir) => {
  *
  * @returns {Promise<boolean>} - Returns a promise that resolves to true if the update is successful.
  */
-const updateProjectConfigs = async ({ clientPropertyId, workingDir, environment = 'production' } = {}) => {
+export async function updateProjectConfigs({ clientPropertyId, workingDir, environment = 'production' } = {}) {
   Hoek.assert(clientPropertyId, 'clientPropertyId is required');
   Hoek.assert(workingDir, 'workingDir is required');
 
@@ -146,7 +145,7 @@ const updateProjectConfigs = async ({ clientPropertyId, workingDir, environment
 
     log.info('Updating configs…');
 
-    const localConfigs = loadLocalConfigs(workingDir);
+    const localConfigs = await loadLocalConfigs(workingDir);
     const { toRemove, toSet } = collateConfigs(api, localConfigs);
 
     // Will throw on first failure
@@ -161,9 +160,9 @@ const updateProjectConfigs = async ({ clientPropertyId, workingDir, environment
     log.error('Failed to apply project configs', error);
     throw error;
   }
-};
+}
 
-const collateConfigs = (api, localConfigs) => {
+export function collateConfigs(api, localConfigs) {
   const toRemove = {};
   const toSet = {};
 
@@ -193,7 +192,7 @@ const collateConfigs = (api, localConfigs) => {
   });
 
   return { toRemove, toSet };
-};
+}
 
 const getUnsetKeysWithDefaults = (defaults = {}, config = {}) => {
   Hoek.assert(typeof defaults === 'object' && defaults !== null, 'defaults must be an object');
@@ -239,10 +238,3 @@ const setConfigs = async (api, toSet) => {
 
   return Promise.all(operations);
 };
-
-module.exports = {
-  getConfigAPI,
-  validateLocalConfigs,
-  updateProjectConfigs,
-  collateConfigs,
-};

package/bin/utils/cpid-lookup.js

@@ -1,14 +1,14 @@
-const axios = require('axios');
-const { log } = require('../utils/logging');
-const { PROPERTY_ID_API, ONE_WEEK } = require('../../constants');
-const chalk = require('chalk');
-const { persistentCacheWithTtl } = require('./persistent-cache-with-ttl');
+import axios from 'axios';
+import chalk from 'chalk';
+import { log } from '../utils/logging.js';
+import { PROPERTY_ID_API, ONE_WEEK } from '../../constants.js';
+import { PersistentCacheWithTtl } from './persistent-cache-with-ttl.js';
 
-const cache = new persistentCacheWithTtl('cpid-cache', {
+const cache = new PersistentCacheWithTtl('cpid-cache', {
   ttl: ONE_WEEK,
 });
 
-exports.doCpidLookup = async (clientPropertyId) => {
+export async function doCpidLookup(clientPropertyId) {
   const API_URL = new URL(clientPropertyId, PROPERTY_ID_API).toString();
 
   const results = await axios
@@ -34,15 +34,15 @@ exports.doCpidLookup = async (clientPropertyId) => {
     rootClientPropertyId: parentCpid ?? clientPropertyId,
     isAffiliate: !!parentCpid,
   };
-};
+}
 
-exports.cpidLookup = async (clientPropertyId, options = {}) => {
+export async function cpidLookup(clientPropertyId, options = {}) {
   if (options.purgeCache) {
     cache.purgeCacheFile();
   }
 
   if (!options.cache) {
-    return this.doCpidLookup(clientPropertyId);
+    return doCpidLookup(clientPropertyId);
   }
 
   const value = cache.get(clientPropertyId);
@@ -51,9 +51,9 @@ exports.cpidLookup = async (clientPropertyId, options = {}) => {
     return value;
   }
 
-  const result = await this.doCpidLookup(clientPropertyId);
+  const result = await doCpidLookup(clientPropertyId);
 
   cache.set(clientPropertyId, result);
 
   return result;
-};
+}

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

@@ -1,8 +1,8 @@
-const simpleGit = require('simple-git');
-const chalk = require('chalk');
-const Hoek = require('@hapi/hoek');
-const dedent = require('dedent');
-const utils = require('./index.js');
+import simpleGit from 'simple-git';
+import chalk from 'chalk';
+import * as Hoek from '@hapi/hoek';
+import dedent from 'dedent';
+import * as utils from './index.js';
 
 /**
  * Validates client property ID found in the fert config against the git url and the package name.
@@ -18,7 +18,7 @@ const utils = require('./index.js');
  *
  */
 
-exports.cpIdMatchesGitRemote = async (fertConfig) => {
+export async function cpIdMatchesGitRemote(fertConfig) {
   const fertConfigDir = await utils.findFertConfigDir();
 
   // Validate that the fert config directory is a git repository
@@ -56,4 +56,4 @@ exports.cpIdMatchesGitRemote = async (fertConfig) => {
   }
 
   return false;
-};
+}

package/bin/utils/getSchemaMeta.js

@@ -1,4 +1,4 @@
-const getSchemaMeta = function getSchemaMeta(schema, key = null) {
+export function getSchemaMeta(schema, key = null) {
   if (!schema || typeof schema.describe !== 'function') {
     throw new Error('Schema is required');
   }
@@ -16,6 +16,4 @@ const getSchemaMeta = function getSchemaMeta(schema, key = null) {
   } catch (error) {
     throw new Error('Invalid Joi schema', { cause: error });
   }
-};
-
-module.exports = { getSchemaMeta };
+}

package/bin/utils/index.js

@@ -1,23 +1,24 @@
-const path = require('node:path');
-const fs = require('node:fs');
+import path from 'node:path';
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
 // eslint-disable-next-line n/no-unsupported-features/node-builtins
-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');
-const simpleGit = require('simple-git');
-const { cpidLookup } = require('./cpid-lookup');
-const { cpIdMatchesGitRemote } = require('./cpid-matches-git-remote');
-const { resolveExternalAssets } = require('./resolve-external-assets');
-const { log } = require('./logging');
-const { CONFIG_API } = require('../../constants');
-
-exports.printBanner = () => {
+import { glob } from 'node:fs/promises';
+import { findUp } from 'find-up-simple';
+import chalk from 'chalk';
+import uuidValidator from 'uuid-validate';
+import * as Hoek from '@hapi/hoek';
+import simpleGit from 'simple-git';
+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';
+
+export function printBanner() {
   console.log(`\n${chalk.green.bold('Fert')} v${VERSION}`);
-};
+}
 
-exports.getConfig = async (cpid, configNames = []) => {
+export async function getConfig(cpid, configNames = []) {
   Hoek.assert(Array.isArray(configNames), 'configNames must be an array');
 
   const result = {};
@@ -31,15 +32,15 @@ exports.getConfig = async (cpid, configNames = []) => {
   }
 
   return result;
-};
+}
 
-exports.resolveConfig = async (options = {}) => {
+export async function resolveConfig(options = {}) {
   Hoek.assert(options.serviceName, 'serviceName is required');
 
-  const rootDir = await this.findFertConfigDir();
+  const rootDir = await findFertConfigDir();
   const git = simpleGit({ baseDir: rootDir });
 
-  const serviceConfigs = await this.loadServiceConfigFiles();
+  const serviceConfigs = await loadServiceConfigFiles();
 
   // workingDir based on service folder
   const { dir: workingDir, serviceConfig } = serviceConfigs.find(
@@ -55,12 +56,12 @@ exports.resolveConfig = async (options = {}) => {
       scripts: [],
     },
   };
-
+  const configFromFile = await loadConfigFromFile({ dir: rootDir });
   const fertConfig = Hoek.applyToDefaults(
     defaults,
     // merge fert config  with service config
     {
-      ...this.loadConfigFromFile({ dir: rootDir }),
+      ...configFromFile,
       ...serviceConfig,
     },
   );
@@ -88,7 +89,7 @@ exports.resolveConfig = async (options = {}) => {
 
   fertConfig.externalAssets = resolveExternalAssets(fertConfig.externalAssets);
 
-  fertConfig.config = await exports.getConfig(fertConfig.clientPropertyId, [
+  fertConfig.config = await getConfig(fertConfig.clientPropertyId, [
     'JobseekerSiteWebSitePath',
     // 'SiteName',
   ]);
@@ -102,7 +103,7 @@ exports.resolveConfig = async (options = {}) => {
     },
     client,
   };
-};
+}
 
 /**
  * Find the root fert config in this project. This is required to
@@ -110,45 +111,43 @@ exports.resolveConfig = async (options = {}) => {
  *
  * @returns {string} closest fert config directory in this folder, or above
  */
-exports.findFertConfigDir = async () => {
-  const { findUp } = await import('find-up-simple');
+export async function findFertConfigDir() {
   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();
+export async function loadServiceConfigFiles() {
+  const rootDir = await 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 serviceConfigPaths = await Array.fromAsync(
+    glob(`**/${FERT_SERVICE_CONFIG_FILENAME}`, {
+      cwd: path.resolve(rootDir),
+      exclude: (item) => ['node_modules', 'dist'].includes(item),
+    }),
+  );
+
+  for await (const filePath of serviceConfigPaths) {
     const dir = path.resolve(rootDir, path.dirname(filePath));
-    const serviceConfig = await this.loadConfigFromFile({
+    const serviceConfig = await loadConfigFromFile({
       dir,
       filename: FERT_SERVICE_CONFIG_FILENAME,
     });
     serviceConfigs.push({ dir, serviceConfig });
   }
   return serviceConfigs;
-};
+}
 
-exports.loadConfigFromFile = ({ dir = process.cwd(), filename = FERT_CONFIG_FILENAME, silent = false }) => {
+export async function 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]) {
-      delete require.cache[configPath];
-    }
-
-    const fertConfig = require(configPath);
+    const { default: fertConfig } = await import(pathToFileURL(configPath));
 
     return fertConfig;
   } catch (err) {
@@ -160,33 +159,33 @@ exports.loadConfigFromFile = ({ dir = process.cwd(), filename = FERT_CONFIG_FILE
     }
   }
   return null;
-};
+}
 
-exports.ensureTrailingSlash = (str) => {
+export function ensureTrailingSlash(str) {
   const lastChar = str.at(-1);
 
   return lastChar === '/' ? str : `${str}/`;
-};
+}
 
-exports.exists = async (_path) => {
+export async function exists(_path) {
   try {
     fs.access(_path);
     return true;
   } catch {
     return false;
   }
-};
+}
 
-exports.isEmptyDir = function isEmptyDir(_path) {
+export function isEmptyDir(_path) {
   const files = fs.readdirSync(_path);
   return files.length === 0 || (files.length === 1 && files[0] === '.git');
-};
+}
 
-exports.formatTargetDir = function formatTargetDir(targetDir) {
+export function formatTargetDir(targetDir) {
   return targetDir?.trim().replace(/\/+$/g, '');
-};
+}
 
-exports.emptyDir = function emptyDir(dir) {
+export function emptyDir(dir) {
   if (!fs.existsSync(dir)) {
     return;
   }
@@ -196,4 +195,4 @@ exports.emptyDir = function emptyDir(dir) {
     }
     fs.rmSync(path.resolve(dir, file), { recursive: true, force: true });
   }
-};
+}

package/bin/utils/logging.js

@@ -1,8 +1,9 @@
-const debug = require('debug');
+import debug from 'debug';
+import chalk from 'chalk';
+
 const debugLog = debug('fert');
-const chalk = require('chalk');
 
-exports.log = {
+export const log = {
   info: (...args) => {
     console.log(...args);
   },

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

@@ -1,14 +1,14 @@
-const { CloudFrontClient, ListDistributionsCommand } = require('@aws-sdk/client-cloudfront');
-const { persistentCacheWithTtl } = require('./persistent-cache-with-ttl');
-const assert = require('node:assert');
-const { ONE_WEEK, AWS_REGION } = require('../../constants');
-const { log } = require('../utils/logging');
+import { CloudFrontClient, ListDistributionsCommand } from '@aws-sdk/client-cloudfront';
+import { PersistentCacheWithTtl } from './persistent-cache-with-ttl.js';
+import assert from 'node:assert';
+import { ONE_WEEK, AWS_REGION } from '../../constants.js';
+import { log } from '../utils/logging.js';
 
-const cache = new persistentCacheWithTtl('cf-distribution-cache', {
+const cache = new PersistentCacheWithTtl('cf-distribution-cache', {
   ttl: ONE_WEEK,
 });
 
-exports.doGetAllCloudFrontDistributions = async () => {
+export async function doGetAllCloudFrontDistributions() {
   const cloudfront = new CloudFrontClient({ region: AWS_REGION });
   const distributions = [];
 
@@ -25,9 +25,9 @@ exports.doGetAllCloudFrontDistributions = async () => {
   } while (isTruncated);
 
   return distributions;
-};
+}
 
-exports.getAllCloudFrontDistributions = async (options = {}) => {
+export async function getAllCloudFrontDistributions(options = {}) {
   assert(options.target, 'Target required');
   const CACHE_KEY = `cf-distributions:${options.target}`;
 
@@ -36,7 +36,7 @@ exports.getAllCloudFrontDistributions = async (options = {}) => {
   }
 
   if (!options.cache) {
-    return this.doGetAllCloudFrontDistributions();
+    return doGetAllCloudFrontDistributions();
   }
 
   const value = cache.get(CACHE_KEY);
@@ -47,24 +47,24 @@ exports.getAllCloudFrontDistributions = async (options = {}) => {
 
   log.info('\nRefreshing CloudFront Distributions cache…');
 
-  const result = await this.doGetAllCloudFrontDistributions();
+  const result = await 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) => {
+export async function getCloudFrontDistributionsForDomain(domain, options) {
   assert(domain && typeof domain === 'string', 'Domain name required');
 
-  const distributions = await this.getAllCloudFrontDistributions(options);
+  const distributions = await getAllCloudFrontDistributions(options);
 
   return distributions.reduce((accum, val) => {
     const { Id, Aliases } = val;
@@ -76,4 +76,4 @@ exports.getCloudFrontDistributionsForDomain = async (domain, options) => {
 
     return accum;
   }, []);
-};
+}

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

@@ -1,26 +1,27 @@
-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');
+import path from 'node:path';
+import assert from 'node:assert';
+import { FlatCache } from 'flat-cache';
+import { TMP_DIR, VERSION } from '../../constants.js';
+import { slug } from './slug.js';
 
-class persistentCacheWithTtl {
+export 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;
+
+    this.createCache();
   }
 
-  _loadCache() {
-    return flatCache.load(this.name, this.cacheDir);
+  createCache() {
+    this.cache = new FlatCache({
+      name: this.name,
+      cacheDir: path.resolve(`${TMP_DIR}/fert-${slug(VERSION)}`),
+    });
   }
 
   set(key, value) {
-    this.cache.setKey(key, {
+    this.cache.set(key, {
       value,
       expire: new Date().getTime() + this.options.ttl,
     });
@@ -29,10 +30,10 @@ class persistentCacheWithTtl {
   }
 
   get(key) {
-    let cachedBlob = this.cache.getKey(key);
+    let cachedBlob = this.cache.get(key);
 
     if (cachedBlob && new Date().getTime() > cachedBlob.expire) {
-      this.cache.removeKey(key);
+      this.cache.delete(key);
       cachedBlob = null;
 
       this.cache.save(true);
@@ -42,8 +43,7 @@ class persistentCacheWithTtl {
   }
 
   purgeCacheFile() {
-    flatCache.clearCacheById(this.name, this.cacheDir);
-    this.cache = this._loadCache();
+    this.cache.destroy();
+    this.createCache();
   }
 }
-exports.persistentCacheWithTtl = persistentCacheWithTtl;

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

@@ -1,4 +1,4 @@
-class LinkAsset {
+export class LinkAsset {
   constructor(arg) {
     this.rel = 'stylesheet';
     this.type = 'text/css';
@@ -18,7 +18,7 @@ class LinkAsset {
   }
 }
 
-class ScriptAsset {
+export class ScriptAsset {
   constructor(arg) {
     this.async = true;
     if (typeof arg === 'string') {
@@ -48,7 +48,7 @@ class ScriptAsset {
   }
 }
 
-function resolveExternalAssets(assets = {}) {
+export function resolveExternalAssets(assets = {}) {
   const result = {
     links: [],
     scripts: [],
@@ -72,9 +72,3 @@ function resolveExternalAssets(assets = {}) {
 
   return result;
 }
-
-module.exports = {
-  LinkAsset,
-  ScriptAsset,
-  resolveExternalAssets,
-};

package/bin/utils/slug.js

@@ -1,6 +1,6 @@
-exports.slug = (txt) => {
+export function slug(txt) {
   return txt
     .toLowerCase()
     .replace(/\W+/g, '-')
     .replace(/^-+|-+$/g, '');
-};
+}