@madgex/fert 4.1.1 → 4.2.0

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/.husky/pre-commit

@@ -1 +1,2 @@
 npm run lint-staged
+npm run test

package/README.md

@@ -217,4 +217,4 @@ 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

@@ -4,6 +4,7 @@ const Hoek = require('@hapi/hoek');
 const { log } = require('../utils/logging');
 const chalk = require('chalk');
 const ora = require('ora');
+const { CONFIG_DIR } = require('../../constants');
 
 /**
  * Validates the local configuration files against the provided schema.
@@ -18,6 +19,13 @@ const ora = require('ora');
 const validateLocalConfigs = async (fertConfig, options = { catch: true }) => {
   Hoek.assert(fertConfig, 'fertConfig is required');
 
+  const dir = path.join(fertConfig.workingDir, CONFIG_DIR);
+  if (!fs.existsSync(dir)) {
+    log.debug(`Directory does not exist: ${dir}`);
+
+    return;
+  }
+
   const api = await getConfigAPI({
     clientPropertyId: fertConfig.clientPropertyId,
   });
@@ -65,13 +73,8 @@ const getConfigAPI = async ({
 };
 
 const loadLocalConfigs = (fertConfig) => {
-  const dir = path.join(fertConfig.workingDir, 'config');
+  const dir = path.join(fertConfig.workingDir, CONFIG_DIR);
   const configs = {};
-
-  if (!fs.existsSync(dir)) {
-    throw new Error(`Directory does not exist: ${dir}`);
-  }
-
   const files = fs.readdirSync(dir);
 
   files.forEach((file) => {
@@ -110,8 +113,15 @@ const updateProjectConfigs = async (
 ) => {
   Hoek.assert(fertConfig, 'fertConfig is required');
 
+  const dir = path.join(fertConfig.workingDir, CONFIG_DIR);
   let spinner;
 
+  if (!fs.existsSync(dir)) {
+    log.debug(`Directory does not exist: ${dir}`);
+
+    return;
+  }
+
   try {
     const api = await getConfigAPI({
       clientPropertyId: fertConfig.clientPropertyId,

package/bin/utils/configs.test.js

@@ -0,0 +1,45 @@
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+const fs = require('node:fs');
+const { validateLocalConfigs, updateProjectConfigs } = require('./configs');
+const { log } = require('../utils/logging');
+
+describe('configs', () => {
+  describe('validateLocalConfigs', () => {
+    it('logs debug message if config directory does not exist', async (t) => {
+      const fsSpy = t.mock.method(fs, 'existsSync');
+      const logSpy = t.mock.method(log, 'debug');
+      const fertConfig = { workingDir: '/non/existent/dir' };
+      let calls;
+
+      await validateLocalConfigs(fertConfig);
+
+      calls = fsSpy.mock.calls;
+      assert.strictEqual(calls[0].arguments[0], '/non/existent/dir/config');
+      assert.strictEqual(fsSpy.mock.calls[0].result, false);
+
+      calls = logSpy.mock.calls;
+      assert.strictEqual(calls.length, 1);
+      assert.strictEqual(typeof calls[0].arguments[0], 'string');
+    });
+  });
+
+  describe('updateProjectConfigs', () => {
+    it('logs debug message if config directory does not exist', async (t) => {
+      const fsSpy = t.mock.method(fs, 'existsSync');
+      const logSpy = t.mock.method(log, 'debug');
+      const fertConfig = { workingDir: '/non/existent/dir' };
+      let calls;
+
+      await updateProjectConfigs(fertConfig);
+
+      calls = fsSpy.mock.calls;
+      assert.strictEqual(calls[0].arguments[0], '/non/existent/dir/config');
+      assert.strictEqual(fsSpy.mock.calls[0].result, false);
+
+      calls = logSpy.mock.calls;
+      assert.strictEqual(calls.length, 1);
+      assert.strictEqual(typeof calls[0].arguments[0], 'string');
+    });
+  });
+});

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/constants.js

@@ -51,4 +51,5 @@ module.exports = {
   ONE_WEEK,
   CONFIG_API:
     'https://configuration-api.job.madgexhosting.net/configs/override/{cpid}/production/clientconfig/{config}',
+  CONFIG_DIR: 'config',
 };

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.1",
+  "version": "4.2.0",
   "description": "Tool to help build the V6 branding",
   "bin": {
     "fert": "./bin/cli.js"
@@ -10,7 +10,7 @@
     "format": "prettier --write .",
     "lint-staged": "lint-staged",
     "semantic-release": "semantic-release",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node --test ./bin/**/*.test.js",
     "prepare": "husky"
   },
   "repository": {
@@ -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.12",
+    "@madgex/design-system": "^9.1.8",
     "@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/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',
-  },
-};