@kiwicom/nitro/bin/nitro.js

#!/usr/bin/env node
// @noflow

/* eslint-disable no-console */
const fs = require("fs-extra");
const path = require("path");
const chalk = require("chalk");
const yargs = require("yargs");
const R = require("ramda");

const collectKeys = require("./scripts/collectKeys");
const fetchBrandConfig = require("./scripts/fetchBrandConfig");
const fetchSpreadsheet = require("./scripts/fetchSpreadsheet");
const { getTranslations, getTranslationsGranular } = require("./scripts/getTranslations");
const missingKeys = require("./scripts/missingKeys");
const { mapLanguages, mapLanguagesGran } = require("./scripts/mapLanguages");

const command = process.argv[2];

const OUT = path.join(process.cwd(), "data");
const TKEYS = path.join(OUT, "tkeys.json");

function log(what) {
  console.log(`${chalk.bold.green(">")} ${what}`);
}

function error(what) {
  console.log(`${chalk.bold.red(">")} ${what}`);
}

// Unstable, not in JS spec
const sortKeys = obj =>
  Object.keys(obj)
    .sort()
    .reduce((acc, key) => ({ ...acc, [key]: obj[key] }), {});

const resolve = glob => path.join(process.cwd(), glob);

const commands = {
  keys: "keys",
  "keys-check": "keys-check",
  translations: "translations",
  fetch: "fetch",
};

const commandOptionsMap = {
  keys: {
    "--no-nitro": "nitro",
  },
};

log(chalk.bold.green("NITRO"));
if (!commands[command]) {
  log("Available commands:");
  log(`  ${chalk.underline.bold("keys")} [...globs]        - collects translation keys`);
  log(`    ${chalk.underline("...globs")} - where to collect keys from`);
  log("");
  log(`  ${chalk.underline.bold("keys-check")}             - checks missing translations`);
  log("");
  log(`  ${chalk.underline.bold("translations")} [--path]  - fetches translations`);
  log(`    ${chalk.underline("--path")} (optional) - where to take translations from`);
  log("");
  log(`  ${chalk.underline.bold("fetch")}                  - fetches production data`);
  log("");
  log("See CLI docs for details at https://github.com/kiwicom/nitrolib");
}

function keys(globs, shouldExcludeNitroTranslations) {
  const ours = shouldExcludeNitroTranslations
    ? []
    : JSON.parse(fs.readFileSync(path.join(__dirname, "../tkeys.json")));

  const collected = collectKeys(globs.map(resolve));

  const data = sortKeys(R.merge(ours, collected));
  fs.outputJsonSync(path.join(OUT, "tkeys.json"), data, {
    spaces: 2,
  });

  log(
    `DONE! Collected ${Object.keys(data).length} keys, out of which ${
      Object.keys(collected).length
    } are your own.`,
  );
}

function keysCheck() {
  const TFILES = path.join(OUT, "translationsFiles.json");
  if (!fs.existsSync(TFILES)) {
    error(
      "Key checking requires the 'data/translationsFiles.json' file. Run 'nitro translations'.",
    );
    process.exit(1);
    return;
  }

  if (!fs.existsSync(TKEYS)) {
    error(
      "'fetch' requires collecting translation keys to a 'data/tkeys.json' file! This can be done using the 'nitro keys <globs>' command.",
    );
    process.exit(1);
    return;
  }

  const missing = missingKeys(OUT, TKEYS, TFILES);
  if (missing.length > 0) {
    missing.forEach(error);
    process.exit(1);
  }

  log("All good.");
}

const TRANSLATIONS_NEEDS = [
  path.join(OUT, "brands.json"),
  path.join(OUT, "languages.json"),
  path.join(OUT, "countries.json"),
  path.join(OUT, "tkeys.json"),
];

const TRANSLATION_GRANS = [
  path.join(OUT, "brands"),
  path.join(OUT, "languages"),
  path.join(OUT, "countries"),
  path.join(OUT, "tkeys.json"),
];

function translations(tFile, granular) {
  if (tFile && !fs.existsSync(tFile)) {
    error(`Translations not found at '${tFile}'`);
    process.exit(1);
    return;
  }
  if (!tFile) {
    try {
      // eslint-disable-next-line no-unused-vars
      const kiwiTranslations = require("@kiwicom/translations");
    } catch (err) {
      error(`'@kiwicom/translations' is not installed and you don't provide path param!`);
      process.exit(1);
      return;
    }
  }

  const good = granular
    ? TRANSLATION_GRANS.reduce((ok, need) => {
        if (!fs.existsSync(need)) {
          error(
            `Task 'translations' requires running the 'keys' and 'fetch' commands first! Missing file: ${need}`,
          );
          return false;
        }
        return ok;
      }, true)
    : TRANSLATIONS_NEEDS.reduce((ok, need) => {
        if (!fs.existsSync(need)) {
          error(
            `Task 'translations' requires running the 'keys' and 'fetch' commands first! Missing file: ${need}`,
          );
          return false;
        }
        return ok;
      }, true);

  if (!good) {
    process.exit(1);
    return;
  }

  if (granular) {
    getTranslationsGranular(TKEYS, tFile)
      .then(mapLanguagesGran)
      .then(() => {
        log("DONE!");
      })
      .catch(err => {
        log(chalk.bold.red("ERROR"));
        error(err);
      });
  } else {
    getTranslations(TKEYS, tFile)
      .then(mapLanguages)
      .then(() => {
        log("DONE!");
      })
      .catch(err => {
        log(chalk.bold.red("ERROR"));
        error(err);
      });
  }
}

function fetch(granular) {
  Promise.all([fetchSpreadsheet(granular), fetchBrandConfig(granular)])
    .then(() => {
      log("DONE!");
    })
    .catch(err => {
      log(chalk.bold.red("ERROR"));
      error(err);
    });
}

if (command === commands.keys) {
  const globs = process.argv.slice(3).filter(a => !commandOptionsMap.keys[a]);
  // yargs casts options starting with --no- into a `false` flag. --no-nitro -> nitro: false
  const shouldExcludeNitroTranslations = commandOptionsMap.keys["--no-nitro"] in yargs.argv;

  keys(globs, shouldExcludeNitroTranslations);
}

if (command === commands["keys-check"]) {
  keysCheck();
}

if (command === commands.translations) {
  translations(yargs.argv.path, yargs.argv.granular);
}

if (command === commands.fetch) {
  fetch(yargs.argv.granular);
}