@madgex/fert 5.0.2 → 5.0.4

package/README.md

@@ -198,7 +198,7 @@ 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`
+`fert publish --target=production` | `fert publish --target=production --service-name=jobseekers-frontend`
 
 Run for 1 service from the service folder:
 `cd services/jobseekers-frontend`
@@ -208,10 +208,10 @@ Run for 1 service from the service folder:
 
 `fert publish  --target [target]`
 
-| Option      |                                                                              |
-| ----------- | ---------------------------------------------------------------------------- |
-| `--target`  | Where to publish the `dist` directory assets.<br/>`dev` \| `prod` (`string`) |
-| `--dry-run` | Dry run, dont actually upload anything                                       |
+| Option      |                                                                                    |
+| ----------- | ---------------------------------------------------------------------------------- |
+| `--target`  | Where to publish the `dist` directory assets.<br/>`dev` \| `production` (`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.
 
@@ -316,7 +316,19 @@ These options are available no matter the command used.
 
 # CI/CD
 
-It's intended that the branding repos have their own build/deploy pipeline. Each change that's merged to `master` will trigger a build (`npm run build` as a common entry point) and the resulting output directory (`dist`) is pushed up to the `asset-store-api` for use in production.
+All branding repos use a common jekinsfile and Dockerfile to build/deploy, and will use this FERT tool.
+
+- Here is the jenkinsfile all branding repos use: https://github.com/wiley/madgex-jenkins-shared-library/blob/master/vars/clientRepoDeploymentPipeline.groovy .
+- And the Dockerfile they all use [is in this repo](shared/Dockerfile.brandingRepoPublish).
+
+Each change that's pushed to a branch will trigger:
+
+1. a build (`npm run build` inside the [Dockerfile](shared/Dockerfile.brandingRepoPublish) as a common entry point), which creates a `dist` folder full of assets ready to upload.
+2. The [jenkinsfile](https://github.com/wiley/madgex-jenkins-shared-library/blob/master/vars/clientRepoDeploymentPipeline.groovy) pipeline will run `fert publish` to send all built assets to the Asset Store API.
+3. The [jenkinsfile](https://github.com/wiley/madgex-jenkins-shared-library/blob/master/vars/clientRepoDeploymentPipeline.groovy) pipeline will run `fert configs --publish`, Uploading the branding repo's client `/configs` to the configuration-api.
+
+> [!NOTE]
+> `master` branch will go to `production`. All other branches will go to `jb dev`.
 
 ## `npm scripts`
 
@@ -330,5 +342,3 @@ 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.

package/bin/cli.js

@@ -37,7 +37,10 @@ const run = () => {
 
   cli
     .command('publish', 'Publish the project')
-    .option('--target <env>', 'Environment to publish to, "dev" or "prod"')
+    .option(
+      '--target <env>',
+      'Environment to publish to, "dev" or "production"'
+    )
     .option('--service-name <serviceName>', '[string] run a single service')
     .option('--dry-run', 'Dry run, dont actually upload anything')
     .action((...args) => serivceCommandBootstrap('publish', ...args));

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

@@ -9,6 +9,7 @@ const commandDevSever = require('./dev-server.js');
 const commandBuild = require('./build.js');
 const commandPublish = require('./publish.js');
 const { FERT_SERVICE_CONFIG_FILENAME } = require('../../constants.js');
+const { log } = require('../utils/logging.js');
 
 const commandMap = {
   dev: commandDevSever,
@@ -54,13 +55,27 @@ module.exports.serivceCommandBootstrap = async function serivceCommandBootstrap(
   }
   // 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) {
-    await commandMap[command]({
-      ...options,
-      serviceName: serviceConfig.serviceName,
-    });
+    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 }
+      );
+    }
   }
 };

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.2",
+  "version": "5.0.4",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"

package/delivery/jenkinsfile

@@ -1,93 +0,0 @@
-#!/usr/bin/env groovy
-library 'jenkins-shared-library'
-
-def productName     =   'rollout-tool'   // the name of the product to which this service belongs (jobboard/insights/employerbranding/core-services)
-
-def (subProductName, branchName)    =   "${env.JOB_NAME}".tokenize( '/' )
-def siteName                        =   "$productName/$subProductName"
-def repositoryUri                   =   "426517516965.dkr.ecr.eu-west-1.amazonaws.com"
-
-pipeline {
-    agent {
-        any {
-            customWorkspace "workspace/${env.JOB_NAME}/${branchName}".replace('%2F', '-')
-        }
-    }
-
-    options {
-        timeout(time: 1, unit: 'HOURS')
-        disableConcurrentBuilds()
-        skipStagesAfterUnstable()
-        skipDefaultCheckout()
-        buildDiscarder(logRotator(daysToKeepStr: '10', numToKeepStr: '3'))
-    }
-
-    environment {
-        NPM_TOKEN = credentials('MDS_NPM_TOKEN')
-        AWS_CREDENTIALS_ID = "${params.ENVIRONMENTS == 'jb.dev' ? 'rollout-tool-consumer-key-parameter-store-jb-dev' : 'rollout-tool-consumer-key-parameter-store-production'}"
-    }
-
-    stages {
-        stage('SCM') {
-            steps {
-                notifySlack('STARTED', 'fed-services-builds', 'jenkins-slack-token')
-                checkout scm
-                notifyBitbucketWithState('INPROGRESS')
-            }
-        }
-
-        stage('Build') {
-            steps {
-                script {
-                    withCredentials([
-                        usernamePassword(credentialsId: 'github-lerna-write', passwordVariable: 'GIT_PASSWORD', usernameVariable: 'GIT_USERNAME'),
-                        [$class: 'AmazonWebServicesCredentialsBinding', credentialsId: "${env.AWS_CREDENTIALS_ID}"]
-                      ]){
-
-                        docker.build("madgex/front-end-rollout-tool", "--no-cache --build-arg NPM_TOKEN=$env.NPM_TOKEN --build-arg GIT_USERNAME=$GIT_USERNAME --build-arg GIT_PASSWORD=$GIT_PASSWORD .")
-
-                        sh """
-                            docker run --rm -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY madgex/front-end-rollout-tool:latest npm run publish -- --environment=${params.ENVIRONMENTS} --clientPropertyId=${params.CLIENT_PROPERTY_ID}
-
-                        """
-                      }
-                }
-            }
-        }
-        stage('Call branding service') {
-            steps {
-                script {
-                    build job: 'madgex-branding-service', parameters: [
-                        string(name: 'CLIENT_PROPERTY_ID', value: params.CLIENT_PROPERTY_ID),
-                        string(name: 'DESIGN_SYSTEM_VERSION', value: params.DESIGN_SYSTEM_VERSION),
-                        string(name: 'ENVIRONMENTS', value: params.ENVIRONMENTS),
-                    ]
-                } 
-            }
-        }
-
-    }
-
-    post {
-        failure {
-            script {
-                notifyBitbucketWithState('FAILURE')
-                // This channel is only for failures
-                notifySlack(currentBuild.result, 'pipeline-alerts-fed', 'jenkins-slack-token')
-            }
-        }
-        success {
-            script {
-                notifyBitbucketWithState('SUCCESS')
-            }
-        }
-        always { 
-            script {
-                // Necessary to get emailer to send out on success
-                currentBuild.result = currentBuild.currentResult
-            }
-            notifySlack(currentBuild.result, 'fed-services-builds', 'jenkins-slack-token')
-            cleanWs deleteDirs: true
-        }
-    }    
-}