@madgex/fert 4.1.2 → 4.2.1

package/.github/workflows/release.yml

@@ -16,10 +16,10 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           cache: npm
-          node-version: 20
+          node-version: 22
 
       - name: Setup SSH Keys and known_hosts
         env:

package/README.md

@@ -190,6 +190,91 @@ 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.
 
+## Configs
+
+`fert configs`
+
+A set of commands to help with publishing, downloading & referencing project configs.
+
+**Usage**
+
+`fert configs [root] --[query|download|publish] [env]`
+
+| Option               | Description                                                                             |
+| -------------------- | --------------------------------------------------------------------------------------- |
+| --query [configName] | Describe known keys for a config, omit to list all known configs                        |
+| --download <env>     | Download known configs from the Configuration API for environment "dev" or "production" |
+| --publish            | Publish configs to Configuration API environment "dev" or "production"                  |
+
+### Example usage
+
+Its assumed you're running from a branding repo in all examples
+
+#### Review all known configs
+
+```bash
+# fert configs --query
+
+Fert v0.0.0-development
+
+Available config schemas...
+ * JobSeekerDesignConfig
+ * JobSeekerSiteConfig
+ * jsfe-config
+ * webconfig
+ ...
+```
+
+#### Review validation schema & default values for a config
+
+```bash
+# fert configs --query JobBoardConfig.filesizeDefinitions
+
+Fert v0.0.0-development
+
+Getting schema description for config: JobBoardConfig.filesizeDefinitions...
+{
+  "documents": {
+    "type": "number",
+    "flags": {
+      "description": "The definition in MBs of how large documents can be",
+      "default": 1
+    }
+  }
+}
+
+Configs default values:
+{
+  "documents": 1
+}
+```
+
+#### Download known configs for the current client (specified in `fert.config.js`) from the Configuration API. This is intended as a one-time command to get the current config values in the repo
+
+```bash
+# fert configs --download production
+
+Fert v0.0.0-development
+✔ Downloading v6 configs...
+Saving files...
+ - JobBoardConfig.applicationForm.json
+ - JobBoardConfig.articlesFilterByDate.json
+ - JobBoardConfig.careerpathCountryIso.json
+ - JobBoardConfig.careerpathGlobalRoleSettings.json
+ ...
+```
+
+#### Publish all known, valid configs found in branding repos `./config/*` for the current client. In this scenario, there is only `./config/jsfe-config.json`
+
+```bash
+# fert configs --publish production
+
+Fert v0.0.0-development
+✔ Config validated: jsfe-config
+✔ Project configs applied to configuration-api.job.madgexhosting.net
+upload
+```
+
 # Global options
 
 These options are available no matter the command used.
@@ -216,5 +301,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

@@ -44,6 +44,10 @@ const run = () => {
       '--publish <env>',
       'Publish configs to Configuration API environment "dev" or "production"'
     )
+    .option(
+      '--download <env>',
+      'Download known configs from the Configuration API for environment "dev" or "production"'
+    )
     .option(
       '--query [configName]',
       'Describe known keys for a config, omit to list all known configs'

package/bin/commands/configs.js

@@ -6,65 +6,167 @@ const {
 } = require('../utils/configs.js');
 const chalk = require('chalk');
 const { log } = require('../utils/logging.js');
+const { getSchemaKeyMeta } = require('../utils/getSchemaKeyMeta.js');
+const ora = require('ora');
+const { mkdir, writeFile } = require('node:fs/promises');
+const Path = require('node:path');
+const { CONFIG_DIR } = require('../../constants.js');
 
-module.exports = async (root, options) => {
-  const fertConfig = await resolveConfig(root, options);
-  const api = await getConfigAPI(fertConfig);
+const handleDownload = async (fertConfig, api, options) => {
+  const validTargets = ['dev', 'production'];
 
-  if (!options.publish && !options.query) {
-    console.log(chalk.red(`Missing required --publish or --query option`));
+  if (!validTargets.includes(options.download)) {
+    throw new Error(
+      `Missing or invalid --download option. Choose from [${validTargets}]`
+    );
   }
 
-  if (options.publish) {
-    const validTargets = ['dev', 'production'];
+  const spinner = ora('Downloading v6 configs...').start();
+  const resultObj = {};
 
-    if (!validTargets.includes(options.publish)) {
-      throw Error(
-        `Missing or invalid --publish option. Choose from [${validTargets}]`
-      );
-    }
+  try {
+    for (const [schemaName, schema] of Object.entries(api.schemas)) {
+      const configs = await api.getSchemaKeys(schemaName);
 
-    try {
-      await validateLocalConfigs(fertConfig, { catch: false });
-      await updateProjectConfigs(fertConfig, { environment: options.publish });
-    } catch (err) {
-      log.debug(err);
-      process.exit(1);
-    }
-  } else if (options.query) {
-    try {
-      if (options.query !== true) {
-        console.log(
-          chalk.cyan(`\nGetting ${options.query} schema description...`)
-        );
-        const schema = api.schemas[options.query];
-        if (!schema) {
-          console.error(chalk.red(`Schema not found for ${options.query}`));
-          return;
+      for (const configKey of configs) {
+        const meta = getSchemaKeyMeta(schema, configKey);
+        if (meta.readOnly) {
+          continue;
         }
 
-        console.log(JSON.stringify(schema.describe().keys, null, 2));
-        console.log(
-          `\n${chalk.cyan('Defaults')}:\n${JSON.stringify(schema.validate({}), null, 2)}`
-        );
-        return;
+        try {
+          const data = await api.getConfig(schemaName, configKey, {
+            useSchema: false,
+          });
+          if (!data.isDefault) {
+            let result = data.result;
+            try {
+              result = JSON.parse(result);
+            } catch (error) {
+              log.debug(
+                `Unable to JSON parse ${chalk.cyan(data.response?.url || schemaName + '/' + configKey)} error:`,
+                error.message
+              );
+            }
+
+            resultObj[schemaName] = {
+              ...result[schemaName],
+              [configKey]: result,
+            };
+          }
+        } catch (error) {
+          log.debug(
+            `Unable to retrieve ${chalk.cyan(error.url || schemaName + '/' + configKey)}`,
+            error.message || error.statusText || error
+          );
+        }
       }
+    }
+
+    spinner.succeed();
+  } catch (error) {
+    spinner.fail(
+      `Error ${error.code ? `[${error.code}]` : ''}: ${error.message}`
+    );
+    throw error;
+  }
+
+  console.log(chalk.green('Saving files...'));
+
+  try {
+    await mkdir(CONFIG_DIR, { recursive: true });
+  } catch (error) {
+    log.debug(`Unable to create directory ${CONFIG_DIR}`, error);
+    // basically ignore error
+  }
+
+  for (const [schemaName, data] of Object.entries(resultObj)) {
+    const filePath = Path.join(CONFIG_DIR, `${schemaName}.json`);
+    await writeFile(filePath, JSON.stringify(data, null, 2));
+    console.log(` - ${schemaName}.json`);
+  }
+};
+
+const handlePublish = async (fertConfig, api, options) => {
+  const validTargets = ['dev', 'production'];
 
-      console.log(chalk.cyan(`\nAvailable config schemas...`));
+  if (!validTargets.includes(options.publish)) {
+    throw new Error(
+      `Missing or invalid --publish option. Choose from [${validTargets}]`
+    );
+  }
+
+  try {
+    await validateLocalConfigs(fertConfig, { catch: false });
+    await updateProjectConfigs(fertConfig, { environment: options.publish });
+    console.log('upload');
+  } catch (err) {
+    log.debug(err);
+    process.exit(1);
+  }
+};
+
+const handleQuery = async (fertConfig, api, options) => {
+  try {
+    if (options.query !== true) {
       console.log(
-        Object.keys(api.schemas)
-          .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
-          .map((key) => ` * ${key}`)
-          .join('\n'),
-        '\n'
+        chalk.cyan(
+          `\nGetting schema description for config: ${chalk.bold(options.query)}...`
+        )
       );
+      const schema = api.schemas[options.query];
+      if (!schema) {
+        console.error(
+          chalk.red(`Schema not found for ${chalk.bold(options.query)}`)
+        );
+        return;
+      }
 
+      console.log(JSON.stringify(schema.describe().keys, null, 2));
       console.log(
-        'Use `fert configs <configName>` to get a specific schema description'
+        `\n${chalk.cyan('Configs default values')}:\n${JSON.stringify(schema.validate({}).value, null, 2)}`
       );
-    } catch (err) {
-      log.debug(err);
-      process.exit(1);
+      return;
     }
+
+    console.log(chalk.cyan(`\nAvailable config schemas...`));
+    console.log(
+      Object.keys(api.schemas)
+        .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+        .map((key) => ` * ${key}`)
+        .join('\n'),
+      '\n'
+    );
+
+    console.log(
+      'Use `fert configs <configName>` to get a specific schema description'
+    );
+  } catch (err) {
+    log.debug(err);
+    process.exit(1);
   }
 };
+
+module.exports = async (root, options) => {
+  const fertConfig = await resolveConfig(root, options);
+  const api = await getConfigAPI(fertConfig);
+
+  if (!options.publish && !options.query && !options.download) {
+    console.log(
+      chalk.red(`Missing required --publish, --query or --download option`)
+    );
+    return;
+  }
+
+  if (options.download) {
+    await handleDownload(fertConfig, api, options);
+  } else if (options.publish) {
+    await handlePublish(fertConfig, api, options);
+  } else if (options.query) {
+    await handleQuery(fertConfig, api, options);
+  }
+};
+
+module.exports.handleDownload = handleDownload;
+module.exports.handlePublish = handlePublish;
+module.exports.handleQuery = handleQuery;

package/bin/commands/configs.test.js

@@ -0,0 +1,162 @@
+const assert = require('node:assert');
+const { describe, it, beforeEach } = require('node:test');
+const fs = require('node:fs/promises');
+const Path = require('node:path');
+const Joi = require('joi');
+
+describe('configs', () => {
+  let fertConfig;
+  let api;
+  let mkdirMock;
+  let writeFileMock;
+  let handleDownload;
+  let handleQuery;
+  let handlePublish;
+
+  beforeEach(async (t) => {
+    fertConfig = {
+      clientPropertyId: 'ff6102ff-0f4b-43d1-a2c7-83b835b8dee5',
+    };
+
+    const { ConfigAPI } = await import('@madgex/config-api-sdk');
+
+    api = new ConfigAPI({
+      clientPropertyId: fertConfig.clientPropertyId,
+      environment: 'dev',
+      schemas: {
+        'jsfe-config': Joi.object({
+          StrConfig: Joi.string().default('My new JSFE config'),
+        }),
+      },
+      fetch: async () => ({
+        ok: true,
+        json: async () => ({
+          status: 'success',
+          data: [
+            {
+              configName: 'jsfe-config',
+              key: 'StrConfig',
+              value: '"hello"',
+            },
+          ],
+        }),
+      }),
+    });
+
+    // Set up mocks before requiring the module that uses them
+    mkdirMock = t.mock.method(fs, 'mkdir', async () => {});
+    writeFileMock = t.mock.method(fs, 'writeFile', async () => {});
+
+    // Clear require cache to ensure we get a fresh copy with our mocks
+    delete require.cache[require.resolve('./configs')];
+    ({ handleDownload, handleQuery, handlePublish } = require('./configs'));
+  });
+
+  describe('handleDownload', () => {
+    let options;
+
+    beforeEach(async () => {
+      options = { download: 'dev' };
+    });
+
+    it('iterates over known schemas', async () => {
+      await handleDownload(fertConfig, api, options);
+
+      assert.strictEqual(Object.keys(api.schemas).length, 1);
+      assert.strictEqual(mkdirMock.mock.calls.length, 1);
+      assert.strictEqual(mkdirMock.mock.calls[0].arguments[0], 'config');
+      assert.strictEqual(writeFileMock.mock.calls.length, 1); // Only one schema
+    });
+
+    it('saves to the expected place', async () => {
+      await handleDownload(fertConfig, api, options);
+
+      assert.strictEqual(writeFileMock.mock.calls.length, 1);
+
+      assert.strictEqual(
+        writeFileMock.mock.calls[0].arguments[0],
+        Path.join('config', 'jsfe-config.json')
+      );
+    });
+
+    it('writes the expected data', async () => {
+      await handleDownload(fertConfig, api, options);
+
+      assert.strictEqual(writeFileMock.mock.calls.length, 1);
+
+      const jsfeConfig = JSON.parse(writeFileMock.mock.calls[0].arguments[1]);
+      assert.strictEqual(Object.keys(jsfeConfig).length, 1);
+      assert.strictEqual(jsfeConfig.StrConfig, 'hello');
+    });
+
+    it('skips read-only keys', async () => {
+      // clone api object including prototype
+      const tweakedApi = Object.assign(
+        Object.create(Object.getPrototypeOf(api)),
+        api
+      );
+
+      tweakedApi.schemas = {
+        'jsfe-config': Joi.object({
+          StrConfig: Joi.string().default('My new JSFE config'),
+          ReadOnlyConfig: Joi.string()
+            .default('I am read-only')
+            .meta({ readOnly: true }),
+        }),
+      };
+
+      await handleDownload(fertConfig, tweakedApi, options);
+
+      assert.strictEqual(writeFileMock.mock.calls.length, 1);
+
+      const jsfeConfig = JSON.parse(writeFileMock.mock.calls[0].arguments[1]);
+      assert.strictEqual(Object.keys(jsfeConfig).length, 1);
+      assert.strictEqual(jsfeConfig.ReadOnlyConfig, undefined);
+    });
+  });
+
+  describe.skip('handlePublish', () => {
+    let options;
+
+    beforeEach(async () => {
+      options = { publish: true };
+    });
+
+    it('publishes the configs', async () => {
+      await handlePublish(fertConfig, api, options);
+    });
+  });
+  describe.skip('handleQuery', () => {
+    let options;
+
+    beforeEach(async () => {
+      options = { query: true };
+    });
+
+    it('logs available schemas if query option is true', async () => {
+      await handleQuery(fertConfig, api, options);
+    });
+
+    it.skip('logs schema description if query option is valid', async (t) => {
+      const api = {
+        schemas: {
+          testSchema: {
+            describe: () => ({ keys: {} }),
+            validate: () => ({}),
+          },
+        },
+      };
+      const options = { query: 'testSchema' };
+      let logMessage = '';
+
+      t.mock.method(console, 'log', (message) => {
+        logMessage += message;
+      });
+
+      await handleQuery(api, options);
+
+      assert(logMessage.includes('Getting testSchema schema description...'));
+      assert(logMessage.includes('Defaults'));
+    });
+  });
+});

package/bin/utils/configs.js

@@ -77,25 +77,27 @@ const loadLocalConfigs = (fertConfig) => {
   const configs = {};
   const files = fs.readdirSync(dir);
 
-  files.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: ${err.message}`);
+  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}`);
+        }
       }
-    }
-  });
+    });
 
   return configs;
 };

package/bin/utils/getSchemaKeyMeta.js

@@ -0,0 +1,14 @@
+const getSchemaKeyMeta = function (schema, key) {
+  if (!schema) throw new Error('Schema is required');
+  if (!key) throw new Error('Key is required');
+
+  const keySchema = schema.extract(key);
+  if (!keySchema) {
+    throw new Error(`Key "${key}" not found in schema`);
+  }
+
+  const metas = keySchema.describe().metas;
+  return Array.isArray(metas) && metas.length > 0 ? metas[0] : {};
+};
+
+module.exports = { getSchemaKeyMeta };

package/bin/utils/index.js

@@ -108,6 +108,8 @@ exports.loadConfigFromFile = (workingDir) => {
       `Failed to load fert.config.js - ensure you're running fert on a branding repo & config exists.\n`
     );
 
+    console.error(err);
+
     process.exit(1);
   }
 };

package/eslint.config.mjs

@@ -0,0 +1,53 @@
+import prettier from 'eslint-plugin-prettier';
+import globals from 'globals';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import js from '@eslint/js';
+import { FlatCompat } from '@eslint/eslintrc';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default [
+  {
+    ignores: [
+      '**/dist',
+      '**/temp',
+      '**/dist',
+      '**/*.json',
+      '**/*.json',
+      '**/.eslintrc.js',
+      '**/node_modules',
+      '**/repo-templates',
+      'eslint.config.mjs',
+    ],
+  },
+  ...compat.extends('eslint:recommended', 'plugin:prettier/recommended'),
+  {
+    plugins: {
+      prettier,
+    },
+
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+
+      ecmaVersion: 'latest',
+      sourceType: 'commonjs',
+
+      parserOptions: {
+        requireConfigFile: false,
+      },
+    },
+
+    rules: {
+      'prettier/prettier': 'error',
+    },
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madgex/fert",
-  "version": "4.1.2",
+  "version": "4.2.1",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"
@@ -23,23 +23,23 @@
   "author": "Madgex",
   "license": "UNLICENSED",
   "dependencies": {
-    "@aws-sdk/client-cloudfront": "^3.670.0",
-    "@aws-sdk/client-ssm": "^3.670.0",
-    "@aws-sdk/credential-providers": "^3.670.0",
-    "@hapi/hapi": "^21.3.10",
-    "@hapi/hoek": "^11.0.4",
+    "@aws-sdk/client-cloudfront": "^3.716.0",
+    "@aws-sdk/client-ssm": "^3.716.0",
+    "@aws-sdk/credential-providers": "^3.716.0",
+    "@hapi/hapi": "^21.3.12",
+    "@hapi/hoek": "^11.0.7",
     "@hapi/inert": "^7.1.0",
     "@hapi/vision": "^7.0.3",
     "@hapipal/toys": "^4.0.0",
-    "@madgex/config-api-sdk": "^1.0.8",
-    "@madgex/design-system": "^9.1.2",
+    "@madgex/config-api-sdk": "^1.0.13",
+    "@madgex/design-system": "^9.1.9",
     "@private/header-footer-podlet-server": "github:wiley/madgex-header-footer-podlet",
-    "axios": "^1.7.7",
+    "axios": "^1.7.9",
     "cac": "^6.7.14",
     "chalk": "4.1.2",
     "chokidar": "^3.5.3",
     "dayjs": "^1.11.13",
-    "debug": "^4.3.4",
+    "debug": "^4.4.0",
     "dedent": "^1.5.3",
     "flat-cache": "^4.0.0",
     "form-data": "^4.0.1",
@@ -49,7 +49,7 @@
     "ora": "5.4.1",
     "prompts": "^2.4.2",
     "rimraf": "^5.0.5",
-    "sass": "^1.80.1",
+    "sass": "^1.83.0",
     "simple-git": "^3.27.0",
     "simple-update-notifier": "^2.0.0",
     "style-dictionary": "3.9.0",
@@ -58,17 +58,20 @@
     "vite-plugin-static-copy": "^0.17.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.6.0",
+    "@commitlint/cli": "^19.6.1",
     "@commitlint/config-conventional": "^19.6.0",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.17.0",
     "commitizen": "^4.3.1",
     "cz-conventional-changelog": "^3.3.0",
-    "eslint": "^8.53.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-prettier": "^5.0.1",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "globals": "^15.14.0",
     "husky": "^9.1.7",
-    "lint-staged": "^15.2.10",
-    "prettier": "^3.3.3",
-    "semantic-release": "^22.0.8"
+    "lint-staged": "^15.3.0",
+    "prettier": "^3.4.2",
+    "semantic-release": "^24.2.0"
   },
   "peerDependencies": {
     "@ctrl/tinycolor": "^3.6.0"

package/server/templates/page1.njk

@@ -30,7 +30,7 @@
         <div class="mds-branded-container mds-branded-container--1 mds-padding-b4 mds-padding-bottom-b5 mds-margin-bottom-b5">
             <h2 class="mds-font-s2">Branded Container</h2>
             <p class="mds-margin-bottom-b4">Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
-            <a href="#" draggable="false" class="mds-button mds-button--neutral mds-button--small">Lorem ipsum</a>
+            <a href="#" draggable="false" class="mds-button mds-button--small">Lorem ipsum</a>
         </div>
         </div>
     </div>

package/shared/README.md

@@ -1,4 +1,4 @@
 The docker file in this folder (`Dockerfile.brandingRepoPublish`) will be used by Jenkins to build and publish the repo assets to S3.
 
 When changes are pushed on a project repo, Jenkins will clone this repo, extract the docker file and use it to build and publish the assets to S3.
-If the changes are on a branch other than master, the assets will be sent to the jb-dev S3 bucket. If the changes are pushed to master, they will be sent to the production bucket.
+If the changes are on a branch other than master, the assets will be sent to the jb-dev S3 bucket. If the changes are pushed to master, they will be sent to the production bucket.

package/.eslintignore

@@ -1,8 +0,0 @@
-dist
-temp
-**/dist
-*.json
-**/*.json
-!.eslintrc.js
-node_modules
-repo-templates

package/.eslintrc.js

@@ -1,15 +0,0 @@
-module.exports = {
-  env: {
-    node: true,
-    es6: true,
-  },
-  plugins: ['prettier'],
-  extends: ['eslint:recommended', 'plugin:prettier/recommended'],
-  parserOptions: {
-    requireConfigFile: false,
-    ecmaVersion: 'latest',
-  },
-  rules: {
-    'prettier/prettier': 'error',
-  },
-};