@madgex/fert 5.0.3 → 5.0.5

package/bin/commands/init.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-unreachable */
 const path = require('node:path');
 const fs = require('node:fs');
 const chalk = require('chalk');
@@ -6,20 +5,17 @@ const prompts = require('prompts');
 const uuidValidator = require('uuid-validate');
 const ora = require('ora');
 const { cpidLookup } = require('../utils/cpid-lookup');
+const fertPackageJSON = require('../../package.json');
 
 const { isEmptyDir, formatTargetDir, emptyDir } = require('../utils/index');
-const { TEMPLATES, FERT_CONFIG_FILENAME } = require('../../constants');
+const { 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;
-  const argClientPropertyId =
-    options.cpid && uuidValidator(options.cpid) ? options.cpid : false;
+  const argClientPropertyId = options.cpid && uuidValidator(options.cpid) ? options.cpid : false;
 
   let targetDir = argTargetDir || path.join(cwd, defaultProjectName);
   let result;
@@ -32,47 +28,22 @@ module.exports = async (root, options = {}) => {
           name: 'cpid',
           message: 'clientPropertyId:',
           validate: (cpid) =>
-            uuidValidator(cpid)
-              ? true
-              : `Invalid UUID, ensure the correct clientPropertyId is entered`,
+            uuidValidator(cpid) ? true : `Invalid UUID, ensure the correct clientPropertyId is entered`,
         },
         {
           type: argTargetDir ? null : 'text',
           name: 'projectName',
           message: 'Project name:',
-          initial: (prev) =>
-            defaultProjectName.replace('{cpid}', prev || argClientPropertyId),
+          initial: (prev) => defaultProjectName.replace('{cpid}', prev || argClientPropertyId),
           onState: (state) => {
             targetDir = formatTargetDir(state.value) || defaultProjectName;
           },
         },
         {
-          type:
-            argTemplate && templateList.includes(argTemplate) ? null : 'select',
-          name: 'template',
-          message:
-            typeof argTemplate === 'string' &&
-            !templateList.includes(argTemplate)
-              ? `"${argTemplate}" isn't a valid template. Please choose from below: `
-              : 'Select a template:',
-          initial: 0,
-          choices: TEMPLATES.map((i) => {
-            return {
-              title: i.display,
-              value: i.name,
-            };
-          }),
-        },
-        {
-          type: () =>
-            !fs.existsSync(targetDir) || isEmptyDir(targetDir)
-              ? null
-              : 'confirm',
+          type: () => (!fs.existsSync(targetDir) || isEmptyDir(targetDir) ? null : 'confirm'),
           name: 'overwrite',
           message: () =>
-            (targetDir === '.'
-              ? 'Current directory'
-              : `Target directory "${targetDir}"`) +
+            (targetDir === '.' ? 'Current directory' : `Target directory "${targetDir}"`) +
             ` is not empty. Remove existing files and continue?`,
         },
         {
@@ -89,32 +60,24 @@ module.exports = async (root, options = {}) => {
         onCancel: () => {
           throw new Error(chalk.red('✖') + ' Operation cancelled');
         },
-      }
+      },
     );
   } catch (cancelled) {
     console.log(cancelled.message);
     return;
   }
 
-  const { overwrite, template, cpid } = result;
-  const templateName = template || argTemplate;
+  const { overwrite, cpid } = result;
   const clientPropertyId = cpid || argClientPropertyId;
   const outDir = targetDir;
 
-  const spinner = ora(
-    `Looking up clientPropertyId: ${chalk.yellow(clientPropertyId)}`
-  ).start();
+  const spinner = ora(`Looking up clientPropertyId: ${chalk.yellow(clientPropertyId)}`).start();
   let clientProperties;
   try {
     clientProperties = await cpidLookup(clientPropertyId, options);
-    spinner.succeed(
-      `Looking up clientPropertyId: ${chalk.green(clientPropertyId)}`
-    );
+    spinner.succeed(`Looking up clientPropertyId: ${chalk.green(clientPropertyId)}`);
   } catch (err) {
-    spinner.fail(
-      `Unable to find client details for '${chalk.red(clientPropertyId)}':`,
-      err.message
-    );
+    spinner.fail(`Unable to find client details for '${chalk.red(clientPropertyId)}':`, err.message);
 
     return;
   }
@@ -127,83 +90,30 @@ module.exports = async (root, options = {}) => {
 
   console.log(`\nScaffolding project in ${chalk.bold(outDir)}…`);
 
-  const templateGlobalsDir = path.resolve(
-    __dirname,
-    '../../repo-templates',
-    `globals`
-  );
-  const templateDir = path.resolve(
-    __dirname,
-    '../../repo-templates',
-    `template-${templateName}`
-  );
-
-  const renameFiles = {
-    _gitignore: '.gitignore',
-  };
-
-  function copy(src, dest) {
-    const stat = fs.statSync(src);
-    if (stat.isDirectory()) {
-      copyDir(src, dest);
-    } else {
-      fs.copyFileSync(src, dest);
-    }
-  }
-
-  function copyDir(srcDir, destDir) {
-    fs.mkdirSync(destDir, { recursive: true });
-    for (const file of fs.readdirSync(srcDir)) {
-      const srcFile = path.resolve(srcDir, file);
-      const destFile = path.resolve(destDir, file);
-      copy(srcFile, destFile);
-    }
-  }
+  // copy boilerplate to output dir
+  const templateDir = path.resolve(__dirname, '../../repo-template');
+  fs.cpSync(templateDir, outDir, { recursive: true });
 
-  const write = (file, content) => {
-    const targetPath = path.join(outDir, renameFiles[file] ?? file);
-    if (content) {
-      fs.writeFileSync(targetPath, content);
-    } else {
-      copy(path.join(templateDir, file), targetPath);
-    }
-  };
-
-  copy(templateGlobalsDir, outDir);
-
-  const files = fs.readdirSync(templateDir);
-  for (const file of files.filter((f) => f !== 'package.json')) {
-    write(file);
-  }
-
-  // create package.json
-  const pkg = JSON.parse(
-    fs.readFileSync(path.join(templateDir, 'package.json'), 'utf-8')
-  );
+  // Update new package.json
+  const pkg = JSON.parse(fs.readFileSync(path.join(outDir, 'package.json'), 'utf-8'));
   pkg.name = `madgex-${clientPropertyId}`;
+  pkg.devDependencies['@madgex/fert'] = `^${fertPackageJSON.version}`;
   pkg.description = `Branding repo for ${clientProperties.brandName}`;
-  write('package.json', JSON.stringify(pkg, null, 2) + '\n');
-
-  // create fert.config.js
-  const fertConfigJs = fs.readFileSync(
-    path.join(outDir, FERT_CONFIG_FILENAME),
-    'utf-8'
-  );
-  write(
-    FERT_CONFIG_FILENAME,
-    fertConfigJs.replace(/{CPID}/gi, clientPropertyId)
-  );
+  pkg.repository.url = `git+https://github.com/wiley/madgex-${clientPropertyId}.git`;
+  pkg.homepage = `https://github.com/wiley/madgex-${clientPropertyId}#readme`;
+  fs.writeFileSync(path.join(outDir, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+
+  // Update fert.config.js
+  const fertConfigPath = path.join(outDir, FERT_CONFIG_FILENAME);
+  const fertConfigJs = fs.readFileSync(fertConfigPath, 'utf-8');
+  fs.writeFileSync(fertConfigPath, fertConfigJs.replace(/{CPID}/gi, clientPropertyId));
 
   const cdProjectName = path.relative(cwd, outDir);
 
   console.log(`\nDone. Now run:\n`);
 
   if (cdProjectName && root !== cwd) {
-    console.log(
-      `  cd ${
-        cdProjectName.includes(' ') ? `"${cdProjectName}"` : cdProjectName
-      }`
-    );
+    console.log(`  cd ${cdProjectName.includes(' ') ? `"${cdProjectName}"` : cdProjectName}`);
   }
 
   console.log(`  npm install`);

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

@@ -19,10 +19,7 @@ module.exports = class AssetStoreUploader {
   }
 
   buildAbsolutePath(relativePath, ...parts) {
-    return new URL(
-      path.posix.join(this.basePath, relativePath, ...parts),
-      this.apiUrl
-    );
+    return new URL(path.posix.join(this.basePath, relativePath, ...parts), this.apiUrl);
   }
 
   async upload(file, dest) {
@@ -106,7 +103,7 @@ module.exports = class AssetStoreUploader {
     log.info(
       `CloudFront cache invalidation sent for the following paths${
         distributionId ? ` (distribution id: ${distributionId})` : ''
-      }:\n${JSON.stringify(paths)}\n`
+      }:\n${JSON.stringify(paths)}\n`,
     );
   }
   // Returns array of all files in provided directory (recursive)

package/bin/commands/publish.js

@@ -5,9 +5,7 @@ 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 { getCloudFrontDistributionsForDomain } = require('../utils/lookup-cf-distribution-ids');
 const {
   ASSET_STORE_API,
   AWS_PARAM_NAME,
@@ -23,13 +21,12 @@ module.exports = async (options) => {
 
   // handle legacy options
   if (options.target === 'prod') {
+    // eslint-disable-next-line no-param-reassign
     options.target = 'production';
   }
 
   if (!validTargets.includes(options.target)) {
-    throw Error(
-      `Missing or invalid --target option. Choose from [${validTargets}]`
-    );
+    throw Error(`Missing or invalid --target option. Choose from [${validTargets}]`);
   }
 
   if (options.dryRun) {
@@ -46,29 +43,18 @@ module.exports = async (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 assetStoreInvPath = Hoek.reachTemplate(
-    templateCtx,
-    ASSET_STORE_INVALIDATION_PATH
-  );
-  const brandedSiteInvPath = Hoek.reachTemplate(
-    templateCtx,
-    BRANDED_SITE_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
-  );
+  const clientCloudFrontDists = await getCloudFrontDistributionsForDomain(siteUrl.hostname, options);
 
   log.info(
     `\nPublishing ${chalk.cyan(localDir)} to ${chalk.green.bold(
-      options.target
-    )} for ${chalk.green(fertConfig.client.brandName)} ${chalk.dim(
-      `(${fertConfig.clientPropertyId})`
-    )}\n`
+      options.target,
+    )} for ${chalk.green(fertConfig.client.brandName)} ${chalk.dim(`(${fertConfig.clientPropertyId})`)}\n`,
   );
 
   try {
@@ -84,9 +70,7 @@ module.exports = async (options) => {
       uploadResult = await assetStore.uploadDir(localDir);
     }
 
-    log.success(
-      `Publish complete in ${((uploadResult?.duration || 1) / 1000).toFixed(0)}s\n`
-    );
+    log.success(`Publish complete in ${((uploadResult?.duration || 1) / 1000).toFixed(0)}s\n`);
 
     // invalidate cloudfront cache
     await assetStore.invalidatePaths([assetStoreInvPath]);
@@ -95,11 +79,7 @@ module.exports = async (options) => {
       await assetStore.invalidatePaths([brandedSiteInvPath], dist.id);
     }
 
-    log.info(
-      `\nNote cloudfront invalidations may take upto ${chalk.yellow(
-        '30 seconds'
-      )} to complete.\n`
-    );
+    log.info(`\nNote cloudfront invalidations may take upto ${chalk.yellow('30 seconds')} to complete.\n`);
   } catch (error) {
     log.error('An error occurred during the publish process', error);
   }

package/bin/utils/configs.js

@@ -16,11 +16,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,
-}) => {
+const validateLocalConfigs = async ({ workingDir, clientPropertyId, throwable = true }) => {
   Hoek.assert(clientPropertyId, 'clientPropertyId is required');
   Hoek.assert(workingDir, 'workingDir is required');
 
@@ -36,55 +32,44 @@ const validateLocalConfigs = async ({
   });
   const localConfigs = loadLocalConfigs(workingDir);
 
-  const validationPromises = Object.keys(localConfigs).map(
-    async (configName) => {
-      try {
-        const schema = api.getSchema(configName);
-        const isSchemaReadOnly = api._isSchemaReadOnly(schema);
+  const validationPromises = Object.keys(localConfigs).map(async (configName) => {
+    try {
+      const schema = api.getSchema(configName);
+      const isSchemaReadOnly = api._isSchemaReadOnly(schema);
 
-        if (isSchemaReadOnly) {
-          throw Error(
-            `You're trying to set values on a read-only (usually V5) config schema: ${configName}`
-          );
-        }
+      if (isSchemaReadOnly) {
+        throw Error(`You're trying to set values on a read-only (usually V5) config schema: ${configName}`);
+      }
 
-        // check the entire config against the config validation
-        const { error } = schema.validate(localConfigs[configName].data);
-        if (error) {
-          throw new Error(
-            `Config invalid: ${chalk.bold(localConfigs[configName].path)} - ${error.message}`
-          );
-        }
+      // check the entire config against the config validation
+      const { error } = schema.validate(localConfigs[configName].data);
+      if (error) {
+        throw new Error(`Config invalid: ${chalk.bold(localConfigs[configName].path)} - ${error.message}`);
+      }
 
-        // validate all keys individually against the schema keys to ensure we're not trying to set any read-only keys
-        const config = localConfigs[configName].data;
-        for (const key in config) {
-          const keySchema = schema.extract(key);
-          if (api._isSchemaReadOnly(keySchema)) {
-            throw new Error(
-              `You're trying to set a read-only key on a config schema: ${configName}/${key}`
-            );
-          }
+      // validate all keys individually against the schema keys to ensure we're not trying to set any read-only keys
+      const config = localConfigs[configName].data;
+      for (const key in config) {
+        const keySchema = schema.extract(key);
+        if (api._isSchemaReadOnly(keySchema)) {
+          throw new Error(`You're trying to set a read-only key on a config schema: ${configName}/${key}`);
         }
+      }
 
-        log.success(`Config validated:`, chalk.bold(configName));
-      } catch (err) {
-        log.error(err.message);
+      log.success(`Config validated:`, chalk.bold(configName));
+    } catch (err) {
+      log.error(err.message);
 
-        if (throwable) {
-          throw err;
-        }
+      if (throwable) {
+        throw err;
       }
     }
-  );
+  });
 
   await Promise.all(validationPromises);
 };
 
-const getConfigAPI = async ({
-  clientPropertyId,
-  environment = 'production',
-} = {}) => {
+const getConfigAPI = async ({ clientPropertyId, environment = 'production' } = {}) => {
   const { ConfigAPI } = await import('@madgex/config-api-sdk');
 
   const api = new ConfigAPI({
@@ -143,11 +128,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',
-} = {}) => {
+const updateProjectConfigs = async ({ clientPropertyId, workingDir, environment = 'production' } = {}) => {
   Hoek.assert(clientPropertyId, 'clientPropertyId is required');
   Hoek.assert(workingDir, 'workingDir is required');
 
@@ -174,7 +155,7 @@ const updateProjectConfigs = async ({
     const { host } = new URL(api.options.apiUrl);
     log.info(``);
     log.info(`Project configs applied to ${chalk.bold(host)}`);
-    return true;
+    return;
   } catch (error) {
     log.info(``);
     log.error('Failed to apply project configs', error);
@@ -186,48 +167,37 @@ const collateConfigs = (api, localConfigs) => {
   const toRemove = {};
   const toSet = {};
 
-  Object.entries(localConfigs).forEach(
-    ([configName, { data: config = {} } = {}]) => {
-      const schema = api.getSchema(configName);
-      const isSchemaReadOnly = api._isSchemaReadOnly(schema);
+  Object.entries(localConfigs).forEach(([configName, { data: config = {} } = {}]) => {
+    const schema = api.getSchema(configName);
+    const isSchemaReadOnly = api._isSchemaReadOnly(schema);
 
-      if (isSchemaReadOnly) {
-        log.warn(`Skipping read-only schema: ${configName}`);
-        return;
-      }
+    if (isSchemaReadOnly) {
+      log.warn(`Skipping read-only schema: ${configName}`);
+      return;
+    }
 
-      const configDefault = api._getDefaultConfig(configName);
+    const configDefault = api._getDefaultConfig(configName);
 
-      const unsetKeysWithDefaults = getUnsetKeysWithDefaults(
-        configDefault,
-        config
-      );
+    const unsetKeysWithDefaults = getUnsetKeysWithDefaults(configDefault, config);
 
-      // remove any keys that are read-only from the unset keys collection
-      // we don't want to be deleting those!
-      for (const key in unsetKeysWithDefaults) {
-        if (api._isSchemaReadOnly(schema.extract(key))) {
-          delete unsetKeysWithDefaults[key];
-        }
+    // remove any keys that are read-only from the unset keys collection
+    // we don't want to be deleting those!
+    for (const key in unsetKeysWithDefaults) {
+      if (api._isSchemaReadOnly(schema.extract(key))) {
+        delete unsetKeysWithDefaults[key];
       }
-
-      toRemove[configName] = Object.keys(unsetKeysWithDefaults);
-      toSet[configName] = config;
     }
-  );
+
+    toRemove[configName] = Object.keys(unsetKeysWithDefaults);
+    toSet[configName] = config;
+  });
 
   return { toRemove, toSet };
 };
 
 const getUnsetKeysWithDefaults = (defaults = {}, config = {}) => {
-  Hoek.assert(
-    typeof defaults === 'object' && defaults !== null,
-    'defaults must be an object'
-  );
-  Hoek.assert(
-    typeof config === 'object' && config !== null,
-    'config must be an object'
-  );
+  Hoek.assert(typeof defaults === 'object' && defaults !== null, 'defaults must be an object');
+  Hoek.assert(typeof config === 'object' && config !== null, 'config must be an object');
 
   const diff = {};
   for (const key in defaults) {
@@ -243,17 +213,12 @@ const removeConfigs = async (api, toRemove) => {
     keys.map(async (key) => {
       try {
         await api.deleteConfig(configName, key);
-        log.success(
-          `Successfully removed ${chalk.bold(key)} from ${chalk.bold(configName)}`
-        );
+        log.success(`Successfully removed ${chalk.bold(key)} from ${chalk.bold(configName)}`);
       } catch (error) {
-        log.error(
-          `Failed to remove ${chalk.bold(key)} from ${chalk.bold(configName)}:`,
-          error
-        );
+        log.error(`Failed to remove ${chalk.bold(key)} from ${chalk.bold(configName)}:`, error);
         throw error;
       }
-    })
+    }),
   );
 
   return Promise.all(operations);
@@ -264,17 +229,12 @@ const setConfigs = async (api, toSet) => {
     Object.entries(config).map(async ([key, value]) => {
       try {
         await api.setConfig(configName, key, value);
-        log.success(
-          `Successfully set ${chalk.bold(key)} in ${chalk.bold(configName)}`
-        );
+        log.success(`Successfully set ${chalk.bold(key)} in ${chalk.bold(configName)}`);
       } catch (error) {
-        log.error(
-          `Failed to set ${chalk.bold(key)} in ${chalk.bold(configName)}:`,
-          error
-        );
+        log.error(`Failed to set ${chalk.bold(key)} in ${chalk.bold(configName)}:`, error);
         throw error;
       }
-    })
+    }),
   );
 
   return Promise.all(operations);

package/bin/utils/cpid-lookup.js

@@ -19,8 +19,8 @@ exports.doCpidLookup = async (clientPropertyId) => {
     .catch((error) => {
       log.error(
         `Unable to lookup CPID [${chalk.yellow(
-          clientPropertyId
-        )}] from ${chalk.cyan(API_URL)}: ${chalk.redBright(error.message)}\n`
+          clientPropertyId,
+        )}] from ${chalk.cyan(API_URL)}: ${chalk.redBright(error.message)}\n`,
       );
 
       throw Error(error.message);

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

@@ -26,10 +26,7 @@ exports.cpIdMatchesGitRemote = async (fertConfig) => {
     baseDir: fertConfig.workingDir,
   };
   const git = simpleGit(simpleGitOptions);
-  Hoek.assert(
-    await git.checkIsRepo(),
-    `detected fert config in${fertConfigDir}, but it 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 {
@@ -38,22 +35,20 @@ exports.cpIdMatchesGitRemote = async (fertConfig) => {
     const repo = parts[parts.length - 1].trim();
     const remoteUrlCpid = repo.split('madgex-')[1].trim().replace('.git', '');
 
-    if (remoteUrlCpid == fertConfig.clientPropertyId) {
+    if (remoteUrlCpid === fertConfig.clientPropertyId) {
       return true;
     }
 
     // Big ugly console message for high visibility.
     console.log(
       dedent`
-        ${chalk.bgRed.bold(
-          '💀 💀 💀 Client Property IDs do not match! 💀 💀 💀 '
-        )}
+        ${chalk.bgRed.bold('💀 💀 💀 Client Property IDs do not match! 💀 💀 💀 ')}
         ${chalk.red('CPID from fert.config.js:')} ${fertConfig.clientPropertyId}
         ${chalk.red('CPID from Git remote URL:')} ${remoteUrlCpid}
         ${chalk.bgYellow.bold(
-          '🤓 Please ensure that the Client Property Id from the fert.config.js and the git remote match 🧐 '
+          '🤓 Please ensure that the Client Property Id from the fert.config.js and the git remote match 🧐 ',
         )}\n
-      `
+      `,
     );
   } catch (error) {
     console.log(error);

package/bin/utils/getSchemaMeta.js

@@ -1,4 +1,4 @@
-const getSchemaMeta = function (schema, key = null) {
+const getSchemaMeta = function getSchemaMeta(schema, key = null) {
   if (!schema || typeof schema.describe !== 'function') {
     throw new Error('Schema is required');
   }