@madgex/fert 5.0.1 → 5.0.3

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

@@ -3,13 +3,16 @@ const chalk = require('chalk');
 const {
   loadServiceConfigFiles,
   loadConfigFromFile,
+  findFertConfigDir,
 } = require('../utils/index.js');
+const { getConfigAPI, validateLocalConfigs } = require('../utils/configs.js');
+const { handlePublish } = require('../commands/configs.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 { log } = require('../utils/logging.js');
 
 const commandMap = {
   dev: commandDevSever,
@@ -33,39 +36,79 @@ module.exports.serivceCommandBootstrap = async function serivceCommandBootstrap(
   }
 
   // explicitly run a single service - if we are inside a service folder
+  let cwdServiceConfig;
   try {
     // try to load service config in process.cwd
-    const serviceConfig = await loadConfigFromFile({
+    cwdServiceConfig = 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
   }
-
+  // found service config in cwd, only load this single service
+  if (cwdServiceConfig) {
+    console.log(`🔦 ${chalk.green('Running single service mode')}`);
+    await commandMap[command]({
+      ...options,
+      serviceName: cwdServiceConfig.serviceName,
+    });
+    return;
+  }
   // not single service - try to find and load all services
   const serviceConfigs = await loadServiceConfigFiles();
+
+  if (!serviceConfigs.length) {
+    log.error('No services found\n');
+    return;
+  }
+
   console.log(
-    `🔦 ${chalk.green('Running multi service mode')}, searching for services`
+    `🔦 ${chalk.green('Running multi service mode')}, calling ${chalk.cyan(command)} on ${chalk.cyan(serviceConfigs.length)} ${serviceConfigs.length === 1 ? 'service' : 'services'} [${serviceConfigs.map((i) => chalk.cyanBright(i?.serviceConfig?.serviceName || 'Unknown')).join(', ')}]`
   );
-  for (const { serviceConfig } of serviceConfigs) {
-    try {
-      await commandMap[command]({
-        ...options,
-        serviceName: serviceConfig.serviceName,
+  try {
+    for (const { serviceConfig } of serviceConfigs) {
+      try {
+        await commandMap[command]({
+          ...options,
+          serviceName: serviceConfig.serviceName,
+        });
+      } catch (err) {
+        throw new Error(
+          `Failed to run command ${command} on service ${serviceConfig.serviceName}: ${err.message}`,
+          { cause: err }
+        );
+      }
+    }
+
+    // if we're publishing, update all configs on configuration API
+    if (command === 'publish') {
+      options.target = options.target === 'dev' ? 'dev' : 'production';
+      const rootDir = await findFertConfigDir();
+      const { clientPropertyId } = await loadConfigFromFile({ dir: rootDir });
+      const api = await getConfigAPI({
+        clientPropertyId,
+        environment: options.target,
       });
-    } catch (error) {
-      log.error('Failed to run command', command, options, serviceConfig);
-      console.error(error);
+
+      // validate & upload local configs to configuration API
+      if (!options.dryRun) {
+        await handlePublish({ clientPropertyId, workingDir: rootDir }, api, {
+          publish: options.target,
+        });
+      } else {
+        await validateLocalConfigs({
+          clientPropertyId,
+          workingDir: rootDir,
+          throwable: true,
+        });
+      }
+
+      log.success(`${chalk.green('Publish completed successfully')}`);
     }
+  } catch (error) {
+    log.error('Failed to run command', command, options);
+    console.error(error);
   }
 };

package/bin/commands/configs.js

@@ -102,7 +102,6 @@ const handlePublish = async (
       clientPropertyId,
       environment: options.publish,
     });
-    console.log('upload');
   } catch (err) {
     log.debug(err);
     process.exit(1);

package/bin/commands/publish.js

@@ -5,10 +5,6 @@ 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,
-  validateLocalConfigs,
-} = require('../utils/configs.js');
 const {
   getCloudFrontDistributionsForDomain,
 } = require('../utils/lookup-cf-distribution-ids');
@@ -23,7 +19,12 @@ const {
 
 module.exports = async (options) => {
   const fertConfig = await resolveConfig(options);
-  const validTargets = ['dev', 'prod'];
+  const validTargets = ['dev', 'prod', 'production'];
+
+  // handle legacy options
+  if (options.target === 'prod') {
+    options.target = 'production';
+  }
 
   if (!validTargets.includes(options.target)) {
     throw Error(
@@ -36,8 +37,8 @@ module.exports = async (options) => {
   }
 
   const templateCtx = {
-    env: options.target === 'prod' ? 'job' : 'jb.dev',
-    Environment_Name: options.target === 'prod' ? 'production' : 'dev',
+    env: options.target === 'dev' ? 'jb.dev' : 'job',
+    Environment_Name: options.target,
     fertConfig,
   };
 
@@ -82,19 +83,6 @@ module.exports = async (options) => {
     if (!options.dryRun) {
       uploadResult = await assetStore.uploadDir(localDir);
     }
-    // validate & upload local configs to configuration API
-    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 || 1) / 1000).toFixed(0)}s\n`

package/bin/utils/configs.js

@@ -3,7 +3,6 @@ const path = require('node:path');
 const Hoek = require('@hapi/hoek');
 const { log } = require('../utils/logging');
 const chalk = require('chalk');
-const ora = require('ora');
 const { CONFIG_DIR } = require('../../constants');
 
 /**
@@ -12,7 +11,7 @@ const { CONFIG_DIR } = require('../../constants');
  * @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.
+ * @param {boolean} [options.throwable=false] - 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.
@@ -153,7 +152,6 @@ const updateProjectConfigs = async ({
   Hoek.assert(workingDir, 'workingDir is required');
 
   const dir = path.join(workingDir, CONFIG_DIR);
-  let spinner;
 
   if (!fs.existsSync(dir)) {
     log.debug(`Directory does not exist: ${dir}`);
@@ -164,22 +162,22 @@ const updateProjectConfigs = async ({
   try {
     await validateLocalConfigs({ clientPropertyId, workingDir });
     const api = await getConfigAPI({ clientPropertyId, environment });
-    spinner = ora('Fetching local configs').start();
+
+    log.info('Updating configs…');
 
     const localConfigs = loadLocalConfigs(workingDir);
     const { toRemove, toSet } = collateConfigs(api, localConfigs);
 
-    spinner.text = 'Updating configs…';
-    await setConfigs(api, toSet, spinner);
-    await removeConfigs(api, toRemove, spinner);
+    // Will throw on first failure
+    await Promise.all([setConfigs(api, toSet), removeConfigs(api, toRemove)]);
 
     const { host } = new URL(api.options.apiUrl);
-    spinner.succeed(`Project configs applied to ${chalk.bold(host)}`);
-
+    log.info(``);
+    log.info(`Project configs applied to ${chalk.bold(host)}`);
     return true;
   } catch (error) {
-    spinner.fail('Failed to apply project configs');
-    log.error(error);
+    log.info(``);
+    log.error('Failed to apply project configs', error);
     throw error;
   }
 };
@@ -241,32 +239,45 @@ const getUnsetKeysWithDefaults = (defaults = {}, config = {}) => {
 };
 
 const removeConfigs = async (api, toRemove) => {
-  const deletePromises = Object.entries(toRemove).flatMap(
-    ([configName, keys]) =>
-      keys.map(async (key) => {
-        try {
-          await api.deleteConfig(configName, key);
-        } catch (error) {
-          log.error('Failed to remove config', { configName, key, error });
-        }
-      })
+  const operations = Object.entries(toRemove).flatMap(([configName, keys]) =>
+    keys.map(async (key) => {
+      try {
+        await api.deleteConfig(configName, key);
+        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
+        );
+        throw error;
+      }
+    })
   );
 
-  await Promise.all(deletePromises);
+  return Promise.all(operations);
 };
 
 const setConfigs = async (api, toSet) => {
-  const setPromises = Object.entries(toSet).flatMap(([configName, config]) =>
+  const operations = Object.entries(toSet).flatMap(([configName, config]) =>
     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)}`
+        );
       } catch (error) {
-        log.error('Failed to set config', { configName, key, value, error });
+        log.error(
+          `Failed to set ${chalk.bold(key)} in ${chalk.bold(configName)}:`,
+          error
+        );
+        throw error;
       }
     })
   );
 
-  await Promise.all(setPromises);
+  return Promise.all(operations);
 };
 
 module.exports = {

package/bin/utils/index.js

@@ -47,6 +47,8 @@ exports.resolveConfig = async (options = {}) => {
     },
   };
 
+  Hoek.assert(options.serviceName, 'serviceName is required');
+
   const rootDir = await this.findFertConfigDir();
   const git = simpleGit({ baseDir: rootDir });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madgex/fert",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"