@madgex/fert 1.3.0

package/bin/commands/build.js

@@ -0,0 +1,42 @@
+const path = require('path');
+const { rimraf } = require('rimraf');
+const { resolveConfig, log } = require('../utils');
+const bundleEntry = require('./build-tasks/bundle-entry');
+const buildCssFromTokens = require('./build-tasks/build-tokens');
+const buildExternalAssets = require('./build-tasks/build-external-assets');
+
+module.exports = async (root, options = {}) => {
+  const fertConfig = await resolveConfig(root, options);
+
+  if (!options.only) {
+    await rimraf(path.resolve(fertConfig.workingDir, 'dist'));
+    await exports.buildTokens(fertConfig, options);
+    await exports.bundleEntry(fertConfig, options);
+
+    return;
+  }
+
+  switch (options.only) {
+    case 'tokens':
+      await exports.buildTokens(fertConfig, options);
+      break;
+    case 'assets':
+      await exports.bundleEntry(fertConfig, options);
+      break;
+    default:
+      log.error('"--only param" not recognixed. Not building.');
+  }
+};
+
+exports = module.exports; // allow default export & { named } exports
+
+// eslint-disable-next-line no-unused-vars
+exports.buildTokens = async (fertConfig, options = {}) => {
+  const { workingDir } = fertConfig;
+  const tokenDist = path.join(workingDir, `/public/tokens/`);
+
+  buildCssFromTokens(workingDir, tokenDist);
+};
+
+exports.bundleEntry = bundleEntry;
+exports.buildExternalAssets = buildExternalAssets;

package/bin/commands/dev-server.js

@@ -0,0 +1,50 @@
+const path = require('path');
+const chalk = require('chalk');
+const open = require('open');
+const chokidar = require('chokidar');
+const { resolveConfig, log } = require('../utils/index.js');
+const { devServer } = require('../../server');
+const { buildTokens, buildExternalAssets } = require('./build.js');
+const {
+  BRAND_JSON_FILENAME,
+  FERT_CONFIG_FILENAME,
+} = require('../../constants.js');
+
+module.exports = async (root, options = {}) => {
+  let fertConfig = await resolveConfig(root, options);
+
+  console.log(
+    `Starting branding server for ${chalk.green(
+      fertConfig.client.brandName
+    )} ${chalk.dim(`(${fertConfig.clientPropertyId})`)}\n`
+  );
+
+  // watch brand.json & fert.config.js - refresh on change
+  const brandPath = path.resolve(fertConfig.workingDir, BRAND_JSON_FILENAME);
+  chokidar.watch(brandPath).on('all', async () => {
+    await buildTokens(fertConfig);
+  });
+
+  const configPath = path.resolve(fertConfig.workingDir, FERT_CONFIG_FILENAME);
+  chokidar.watch(configPath).on('change', async () => {
+    console.log('Config changed, reloading…');
+    fertConfig = await resolveConfig(root, options);
+    await buildExternalAssets(fertConfig);
+
+    // update server's config & tell Vite to refresh the page
+    server.fertConfig({ update: fertConfig });
+    server.app.viteServer.ws.send({
+      type: 'full-reload',
+      path: '*',
+    });
+  });
+
+  // start server
+  const server = await devServer({ start: true, fertConfig });
+
+  log.info(`\nDev server: ${chalk.cyan.bold(server.info.uri)}`);
+
+  if (options.open) {
+    await open(server.info.uri);
+  }
+};

package/bin/commands/init.js

@@ -0,0 +1,207 @@
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const prompts = require('prompts');
+const uuidValidator = require('uuid-validate');
+const ora = require('ora');
+const { cpidLookup } = require('../utils/cpid-lookup');
+
+const { isEmptyDir, formatTargetDir, emptyDir } = require('../utils/index');
+const { TEMPLATES } = require('../../constants');
+
+const cwd = process.cwd();
+const templateList = TEMPLATES.map((i) => i.name);
+
+module.exports = async (root, options = {}) => {
+  const defaultProjectName = 'madgex-{cpid}';
+  const argTargetDir = root ? formatTargetDir(root) : null;
+  const argTemplate = options.template;
+  const argClientPropertyId =
+    options.cpid && uuidValidator(options.cpid) ? options.cpid : false;
+
+  let targetDir = argTargetDir || path.join(cwd, defaultProjectName);
+  let result;
+
+  try {
+    result = await prompts(
+      [
+        {
+          type: argClientPropertyId ? null : 'text',
+          name: 'cpid',
+          message: 'clientPropertyId:',
+          validate: (cpid) =>
+            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),
+          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',
+          name: 'overwrite',
+          message: () =>
+            (targetDir === '.'
+              ? 'Current directory'
+              : `Target directory "${targetDir}"`) +
+            ` is not empty. Remove existing files and continue?`,
+        },
+        {
+          type: (_, { overwrite }) => {
+            if (overwrite === false) {
+              throw new Error(chalk.red('✖') + ' Operation cancelled');
+            }
+            return null;
+          },
+          name: 'overwriteChecker',
+        },
+      ],
+      {
+        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 clientPropertyId = cpid || argClientPropertyId;
+  const outDir = targetDir;
+
+  const spinner = ora(
+    `Looking up clientPropertyId: ${chalk.yellow(clientPropertyId)}`
+  ).start();
+  let clientProperties;
+  try {
+    clientProperties = await cpidLookup(clientPropertyId);
+    spinner.succeed(
+      `Looking up clientPropertyId: ${chalk.green(clientPropertyId)}`
+    );
+  } catch (err) {
+    spinner.fail(
+      `Unable to find client details for '${chalk.red(clientPropertyId)}':`,
+      err.message
+    );
+
+    return;
+  }
+
+  if (overwrite) {
+    emptyDir(outDir);
+  } else if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+
+  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);
+    }
+  }
+
+  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')
+  );
+  pkg.name = `madgex-${clientPropertyId}`;
+  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.js'),
+    'utf-8'
+  );
+  write('fert.config.js', 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(`  npm install`);
+  console.log(`  npm run dev`);
+  console.log();
+};

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

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+const Hoek = require('@hapi/hoek');
+const { log } = require('../../utils');
+const axios = require('axios');
+const FormData = require('form-data');
+const ora = require('ora');
+const chalk = require('chalk');
+const { ASSET_STORE_USER_GUID } = require('../../../constants');
+
+module.exports = class AssetStoreUploader {
+  constructor(options = {}) {
+    Hoek.assert(options.apiUrl, 'apiUrl required');
+    Hoek.assert(options.apiKey, 'apiKey required');
+
+    this.apiUrl = options.apiUrl;
+    this.apiKey = options.apiKey;
+    this.basePath = options.basePath ?? '/api/assets';
+  }
+
+  buildAbsolutePath(relativePath, ...parts) {
+    return new URL(
+      path.posix.join(this.basePath, relativePath, ...parts),
+      this.apiUrl
+    );
+  }
+
+  async upload(file, dest) {
+    const absoluteUrl = this.buildAbsolutePath(dest, path.basename(file));
+    const label = absoluteUrl.pathname;
+
+    log.debug('upload', { file, dest, absoluteUrl });
+
+    const form = new FormData();
+    form.append('data', fs.createReadStream(file));
+    form.append('modifiedById', ASSET_STORE_USER_GUID);
+
+    const spinner = ora(`${chalk.yellow('Uploading')}: ${label}`).start();
+
+    return axios
+      .put(absoluteUrl.href, form, {
+        headers: {
+          apikey: this.apiKey,
+          ...form.getHeaders(),
+        },
+      })
+      .then(() => {
+        spinner.succeed(`${label}`);
+      })
+      .catch((err) => {
+        spinner.fail(`Failed to upload '${label}':`, err.message);
+
+        throw err;
+      });
+  }
+
+  async uploadDir(dir, dest = false) {
+    Hoek.assert(dir, 'dir missing');
+
+    const start = process.hrtime();
+    const files = this._getFilesFromDir(dir);
+
+    // Send files consecutively to avoid straining the api
+    for (const file of files) {
+      const relativeName = path.posix.relative(dir, file);
+      const remotePath = path.posix.dirname(dest || relativeName);
+
+      await this.upload(file, remotePath);
+    }
+
+    const end = process.hrtime(start);
+    const duration = end[0] * 1e3 + end[1] * 1e-6;
+
+    return {
+      files,
+      duration,
+    };
+  }
+
+  // Returns array of all files in provided directory (recursive)
+  _getFilesFromDir = (dir, files = []) => {
+    fs.readdirSync(dir).forEach((entry) => {
+      const name = path.join(dir, entry);
+
+      if (fs.statSync(name).isDirectory()) {
+        this._getFilesFromDir(name, files);
+      } else {
+        files.push(name);
+      }
+    });
+
+    return files;
+  };
+};

package/bin/commands/publish-tasks/get-aws-parameter.js

@@ -0,0 +1,41 @@
+const { SSMClient, GetParameterCommand } = require('@aws-sdk/client-ssm');
+const { fromEnv } = require('@aws-sdk/credential-providers');
+const { AWS_REGION } = require('../../../constants');
+
+/**
+ * Gets AWS parameter from the parameter store
+ *
+ * @function getAwsParam
+ *
+ * @async
+ *
+ * @param {string} paramName the name of the parameter we want from AWS parameter store.
+ *
+ * @returns {Promise<{ value: string | undefined }>} the value of the requested AWS parameter
+ *
+ */
+const getAwsParam = async (paramName) => {
+  const client = new SSMClient({
+    region: AWS_REGION,
+    credentials: fromEnv(),
+  });
+  const input = {
+    Name: paramName,
+    WithDecryption: true,
+  };
+  const command = new GetParameterCommand(input);
+  let result;
+
+  try {
+    const response = await client.send(command);
+
+    result = response.Parameter.Value;
+  } catch (error) {
+    console.log(`parameter-store error (${paramName}) ${error.message}`, error);
+    process.exit(1);
+  }
+
+  return result;
+};
+
+module.exports = getAwsParam;

package/bin/commands/publish.js

@@ -0,0 +1,51 @@
+const path = require('path');
+const Hoek = require('@hapi/hoek');
+const chalk = require('chalk');
+const { resolveConfig, log } = require('../utils');
+const getAwsParam = require('./publish-tasks/get-aws-parameter');
+const AssetStoreUploader = require('./publish-tasks/asset-store-uploader');
+const {
+  ASSET_STORE_API,
+  AWS_PARAM_NAME,
+  REMOTE_UPLOAD_BASE,
+  UPLOAD_DIR,
+} = require('../../constants');
+
+module.exports = async (root, options) => {
+  const fertConfig = await resolveConfig(root, options);
+  const validTargets = ['dev', 'prod'];
+
+  if (!validTargets.includes(options.target)) {
+    throw Error(
+      `Missing or invalid --target option. Choose from [${validTargets}]`
+    );
+  }
+
+  const templateCtx = {
+    env: options.target === 'prod' ? 'job' : 'jb.dev',
+    Environement_Name: options.target === 'prod' ? 'production' : 'dev',
+    fertConfig,
+  };
+
+  const localDir = path.resolve(fertConfig.workingDir, UPLOAD_DIR);
+  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 apiKey = await getAwsParam(apiKeyParamPath);
+
+  log.info(
+    `Publishing ${chalk.cyan(localDir)} to ${chalk.green.bold(options.target)}`
+  );
+
+  // send to S3 using the Asset Store API
+  const assetStore = new AssetStoreUploader({
+    apiUrl,
+    apiKey,
+    basePath: remoteBasePath,
+  });
+
+  const result = await assetStore.uploadDir(localDir);
+
+  log.success(`Publish complete in ${(result.duration / 1000).toFixed(0)}s\n`);
+};

package/bin/utils/cpid-lookup.js

@@ -0,0 +1,47 @@
+// Fetch provides support for node 16 and lower
+const fetch = require('node-fetch-commonjs');
+const storage = require('node-persist');
+const dayjs = require('dayjs');
+const duration = require('dayjs/plugin/duration');
+const { PROPERTY_ID_API, TMP_DIR } = require('../../constants');
+
+dayjs.extend(duration);
+
+exports.doCpidLookup = async (clientPropertyId) => {
+  const API_URL = new URL(clientPropertyId, PROPERTY_ID_API).toString();
+
+  const res = await fetch(API_URL);
+
+  if (!res.ok) {
+    throw Error(`Unable to lookup CPID [${clientPropertyId}]`);
+  }
+
+  const { data: results } = await res.json();
+  const { brandName, parentId: parentCpid } = results;
+
+  return {
+    brandName,
+    parentCpid: parentCpid ?? false,
+    rootClientPropertyId: parentCpid ?? clientPropertyId,
+    isAffiliate: !!parentCpid,
+  };
+};
+
+exports.cpidLookup = async (clientPropertyId) => {
+  await storage.init({
+    dir: `${TMP_DIR}/fert-cpid-cache`,
+    ttl: dayjs.duration(1, 'week').asMilliseconds(),
+  });
+
+  const value = await storage.getItem(clientPropertyId);
+
+  if (value) {
+    return value;
+  }
+
+  const result = await this.doCpidLookup(clientPropertyId);
+
+  await storage.updateItem(clientPropertyId, result);
+
+  return result;
+};

package/bin/utils/index.js

@@ -0,0 +1,121 @@
+const path = require('path');
+const fs = require('fs');
+const fsp = require('fs/promises');
+const { VERSION } = require('../../constants');
+const chalk = require('chalk');
+const debug = require('debug');
+const debugLog = debug('fert');
+const uuidValidator = require('uuid-validate');
+const Hoek = require('@hapi/hoek');
+const { cpidLookup } = require('./cpid-lookup');
+const resolveExternalAssets = require('./resolve-external-assets');
+
+exports.printBanner = () => {
+  console.log(chalk`\n{green.bold Fert} v${VERSION}\n`);
+};
+
+exports.log = {
+  info: (...args) => {
+    console.log(...args);
+  },
+  success: (...args) => {
+    console.log(chalk.green.bold('✔'), ...args);
+  },
+  error: (...args) => {
+    console.log(chalk.red.bold('✖'), ...args);
+  },
+  debug: (...args) => {
+    debugLog(...args);
+  },
+};
+
+exports.resolveConfig = async (root, options = {}) => {
+  const defaults = {
+    clientPropertyId: null,
+    entry: 'src/index.js',
+    externalAssets: {
+      links: [],
+      scripts: [],
+    },
+  };
+
+  const workingDir = root ? path.resolve(root) : path.resolve(process.cwd());
+  const fertConfig = Hoek.applyToDefaults(
+    defaults,
+    this.loadConfigFromFile(workingDir)
+  );
+  const client = await cpidLookup(fertConfig.clientPropertyId);
+
+  Hoek.assert(
+    uuidValidator(fertConfig.clientPropertyId),
+    `Invalid clientPropertyId specified in fert.config.js: ${fertConfig.clientPropertyId}`
+  );
+
+  fertConfig.externalAssets = resolveExternalAssets(fertConfig.externalAssets);
+
+  return {
+    ...fertConfig,
+    workingDir,
+    cli: {
+      ...options,
+    },
+    client,
+  };
+};
+
+exports.loadConfigFromFile = (workingDir) => {
+  const configPath = path.resolve(workingDir, 'fert.config.js');
+
+  try {
+    // always return fresh config
+    if (require.cache[configPath]) {
+      delete require.cache[configPath];
+    }
+
+    const fertConfig = require(configPath);
+
+    return fertConfig;
+  } catch (err) {
+    this.log.error(
+      `Failed to load fert.config.js - ensure you're running fert on a branding repo & config exists.\n`
+    );
+
+    process.exit(1);
+  }
+};
+
+exports.ensureTrailingSlash = (str) => {
+  const lastChar = str.at(-1);
+
+  return lastChar === '/' ? str : `${str}/`;
+};
+
+exports.exists = async (path) => {
+  try {
+    await fsp.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+exports.isEmptyDir = function isEmptyDir(path) {
+  const files = fs.readdirSync(path);
+  return files.length === 0 || (files.length === 1 && files[0] === '.git');
+};
+
+exports.formatTargetDir = function formatTargetDir(targetDir) {
+  return targetDir?.trim().replace(/\/+$/g, '');
+};
+
+exports.emptyDir = function emptyDir(dir) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  for (const file of fs.readdirSync(dir)) {
+    if (file === '.git') {
+      continue;
+    }
+    fs.rmSync(path.resolve(dir, file), { recursive: true, force: true });
+  }
+};